diff --git a/lib/clif-backend/src/codegen.rs b/lib/clif-backend/src/codegen.rs index 82168a45a..cb11f725d 100644 --- a/lib/clif-backend/src/codegen.rs +++ b/lib/clif-backend/src/codegen.rs @@ -3,8 +3,8 @@ use cranelift_codegen::cursor::FuncCursor; use cranelift_codegen::ir::immediates::{Offset32, Uimm64}; use cranelift_codegen::ir::types::{self, *}; use cranelift_codegen::ir::{ - self, AbiParam, ArgumentPurpose, ExtFuncData, ExternalName, FuncRef, InstBuilder, Signature, - TrapCode, condcodes::IntCC, + self, condcodes::IntCC, AbiParam, ArgumentPurpose, ExtFuncData, ExternalName, FuncRef, + InstBuilder, Signature, TrapCode, }; use cranelift_codegen::isa::TargetFrontendConfig; use cranelift_entity::{EntityRef, PrimaryMap}; @@ -14,9 +14,13 @@ use cranelift_wasm::{ ReturnMode, SignatureIndex, Table, TableIndex, WasmResult, }; use hashbrown::HashMap; +use std::mem; use target_lexicon; use wasmer_runtime::{ - module::{ModuleInner as WasmerModule, DataInitializer, Export, ImportName, TableInitializer}, + backend::SigRegistry, + module::{ + DataInitializer, ExportIndex, ImportName, ModuleInner as WasmerModule, TableInitializer, + }, types::{ ElementType as WasmerElementType, FuncIndex as WasmerFuncIndex, FuncSig as WasmerSignature, Global as WasmerGlobal, GlobalDesc as WasmerGlobalDesc, GlobalIndex as WasmerGlobalIndex, @@ -25,7 +29,6 @@ use wasmer_runtime::{ TableIndex as WasmerTableIndex, Type as WasmerType, }, vm::{self, Ctx as WasmerVMContext}, - backend::SigRegistry, LinearMemory, }; @@ -61,7 +64,11 @@ pub mod converter { let mut func_assoc: Map = Map::with_capacity(cranelift_module.functions.len()); for (_, signature_index) in cranelift_module.functions.iter() { - func_assoc.push(cranelift_module.sig_registry.lookup_deduplicated_sigindex(WasmerSignatureIndex::new(signature_index.index()))); + func_assoc.push( + cranelift_module.sig_registry.lookup_deduplicated_sigindex( + WasmerSignatureIndex::new(signature_index.index()), + ), + ); } let function_bodies: Vec<_> = cranelift_module @@ -241,7 +248,7 @@ pub struct CraneliftModule { pub imported_globals: Map, // An hash map holding information about the wasm instance exports. - pub exports: HashMap, + pub exports: HashMap, // Data to initialize in memory. pub data_initializers: Vec, @@ -418,28 +425,30 @@ impl<'environment> FuncEnvironmentTrait for FuncEnvironment<'environment> { /// by `index`. /// /// The index space covers both imported and locally declared tables. - fn make_table(&mut self, func: &mut ir::Function, index: TableIndex) -> ir::Table { + fn make_table(&mut self, func: &mut ir::Function, table_index: TableIndex) -> ir::Table { // Only the first table is supported for now. - debug_assert_eq!(index.index(), 0, "non-default tables not supported yet"); + debug_assert_eq!( + table_index.index(), + 0, + "non-default tables not supported yet" + ); // Create VMContext value. let vmctx = func.create_global_value(ir::GlobalValueData::VMContext); - let ptr_size = self.pointer_bytes(); - let tables_offset = WasmerVMContext::offset_tables(); // Load value at (vmctx + memories_offset) which is the address at Ctx.tables. let base = func.create_global_value(ir::GlobalValueData::Load { base: vmctx, - offset: Offset32::new(tables_offset as i32), + offset: (vm::Ctx::offset_tables() as i32).into(), global_type: self.pointer_type(), readonly: true, }); // *Ctx.tables -> [ {data: *usize, len: usize}, {data: *usize, len: usize}, ... ] // Based on the index provided, we need to know the offset into tables array. - let table_data_offset = (index.as_u32() as i32) * (ptr_size as i32) * 2; + let table_data_offset = table_index.index() * mem::size_of::(); - let table_data = func.create_global_value(ir::GlobalValueData::IAddImm { + let table_data_struct = func.create_global_value(ir::GlobalValueData::IAddImm { base, offset: (table_data_offset as i64).into(), global_type: self.pointer_type(), @@ -447,16 +456,16 @@ impl<'environment> FuncEnvironmentTrait for FuncEnvironment<'environment> { // Load value at (base + table_data_offset), i.e. the address at Ctx.tables[index].data let base_gv = func.create_global_value(ir::GlobalValueData::Load { - base: table_data, - offset: 0.into(), + base: table_data_struct, + offset: (vm::LocalTable::offset_base() as i32).into(), global_type: self.pointer_type(), readonly: false, }); // Load value at (base + table_data_offset), i.e. the value at Ctx.tables[index].len let bound_gv = func.create_global_value(ir::GlobalValueData::Load { - base, - offset: (self.pointer_bytes() as i32).into(), + base: table_data_struct, + offset: (vm::LocalTable::offset_current_elements() as i32).into(), global_type: self.pointer_type(), readonly: false, }); @@ -466,8 +475,8 @@ impl<'environment> FuncEnvironmentTrait for FuncEnvironment<'environment> { base_gv, min_size: Uimm64::new(0), bound_gv, - element_size: Uimm64::new(u64::from(self.pointer_bytes() * 2)), - index_type: self.pointer_type(), + element_size: Uimm64::new(mem::size_of::() as u64), + index_type: I32, }) } @@ -517,44 +526,47 @@ impl<'environment> FuncEnvironmentTrait for FuncEnvironment<'environment> { callee: ir::Value, call_args: &[ir::Value], ) -> WasmResult { - // Create a VMContext value. - let vmctx = pos - .func - .special_param(ir::ArgumentPurpose::VMContext) - .expect("missing vmctx parameter"); - // Get the pointer type based on machine's pointer size. let ptr_type = self.pointer_type(); // The `callee` value is an index into a table of function pointers. - // Set callee to an appropriate type based on machine's pointer size. - let callee_offset = if ptr_type == I32 { - callee - } else { - pos.ins().uextend(ptr_type, callee) - }; - - // The `callee` value is an index into a table of function pointers. - let entry_addr = pos.ins().table_addr(ptr_type, table, callee_offset, 0); + let entry_addr = pos.ins().table_addr(ptr_type, table, callee, 0); let mflags = ir::MemFlags::trusted(); - let func_ptr = pos.ins().load(ptr_type, mflags, entry_addr, 0); + let func_ptr = pos.ins().load( + ptr_type, + mflags, + entry_addr, + vm::Anyfunc::offset_func() as i32, + ); + let vmctx_ptr = pos.ins().load( + ptr_type, + mflags, + entry_addr, + vm::Anyfunc::offset_vmctx() as i32, + ); + let found_sig = + pos.ins() + .load(I32, mflags, entry_addr, vm::Anyfunc::offset_sig_id() as i32); pos.ins().trapz(func_ptr, TrapCode::IndirectCallToNull); - let found_sig = pos.ins().load(I32, mflags, entry_addr, self.pointer_bytes() as i32); - let deduplicated_sig_index = self.module.sig_registry.lookup_deduplicated_sigindex(WasmerSignatureIndex::new(sig_index.index())); + let deduplicated_sig_index = self + .module + .sig_registry + .lookup_deduplicated_sigindex(WasmerSignatureIndex::new(sig_index.index())); let expected_sig = pos.ins().iconst(I32, deduplicated_sig_index.index() as i64); let not_equal_flags = pos.ins().ifcmp(found_sig, expected_sig); - pos.ins().trapif(IntCC::NotEqual, not_equal_flags, TrapCode::BadSignature); + pos.ins() + .trapif(IntCC::NotEqual, not_equal_flags, TrapCode::BadSignature); // Build a value list for the indirect call instruction containing the call_args // and the vmctx parameter. let mut args = Vec::with_capacity(call_args.len() + 1); args.extend(call_args.iter().cloned()); - args.push(vmctx); + args.push(vmctx_ptr); Ok(pos.ins().call_indirect(sig_ref, func_ptr, &args)) } @@ -569,7 +581,6 @@ impl<'environment> FuncEnvironmentTrait for FuncEnvironment<'environment> { call_args: &[ir::Value], ) -> WasmResult { // Insert call instructions for `callee`. - if callee_index.index() < self.module.imported_functions.len() { // this is an imported function let vmctx = pos.func.create_global_value(ir::GlobalValueData::VMContext); @@ -595,20 +606,25 @@ impl<'environment> FuncEnvironmentTrait for FuncEnvironment<'environment> { readonly: true, }); + let imported_vmctx_addr = pos.func.create_global_value(ir::GlobalValueData::Load { + base: imported_func_struct_addr, + offset: (vm::ImportedFunc::offset_vmctx() as i32).into(), + global_type: self.pointer_type(), + readonly: true, + }); + let imported_func_addr = pos .ins() .global_value(self.pointer_type(), imported_func_addr); + let imported_vmctx_addr = pos + .ins() + .global_value(self.pointer_type(), imported_vmctx_addr); let sig_ref = pos.func.dfg.ext_funcs[callee].signature; - let vmctx = pos - .func - .special_param(ir::ArgumentPurpose::VMContext) - .expect("missing vmctx parameter"); - let mut args = Vec::with_capacity(call_args.len() + 1); args.extend(call_args.iter().cloned()); - args.push(vmctx); + args.push(imported_vmctx_addr); Ok(pos .ins() @@ -910,28 +926,28 @@ impl<'data> ModuleEnvironment<'data> for CraneliftModule { fn declare_func_export(&mut self, func_index: FuncIndex, name: &'data str) { self.exports.insert( String::from(name), - Export::Func(WasmerFuncIndex::new(func_index.index())), + ExportIndex::Func(WasmerFuncIndex::new(func_index.index())), ); } /// Declares a table export to the environment. fn declare_table_export(&mut self, table_index: TableIndex, name: &'data str) { self.exports.insert( String::from(name), - Export::Table(WasmerTableIndex::new(table_index.index())), + ExportIndex::Table(WasmerTableIndex::new(table_index.index())), ); } /// Declares a memory export to the environment. fn declare_memory_export(&mut self, memory_index: MemoryIndex, name: &'data str) { self.exports.insert( String::from(name), - Export::Memory(WasmerMemoryIndex::new(memory_index.index())), + ExportIndex::Memory(WasmerMemoryIndex::new(memory_index.index())), ); } /// Declares a global export to the environment. fn declare_global_export(&mut self, global_index: GlobalIndex, name: &'data str) { self.exports.insert( String::from(name), - Export::Global(WasmerGlobalIndex::new(global_index.index())), + ExportIndex::Global(WasmerGlobalIndex::new(global_index.index())), ); } diff --git a/lib/clif-backend/src/libcalls.rs b/lib/clif-backend/src/libcalls.rs index 661d74d40..d7fe5ab5a 100644 --- a/lib/clif-backend/src/libcalls.rs +++ b/lib/clif-backend/src/libcalls.rs @@ -13,7 +13,7 @@ pub extern "C" fn truncf32(x: f32) -> f32 { x.trunc() } -/// `f32.round()` doesn't have the correct behavior. Ideally, we'd use +/// `f32.round()` doesn't have the correct behavior. Ideally, we'd use /// "https://doc.rust-lang.org/std/intrinsics/fn.nearbyintf32.html" for this, /// but support for stable compilers is necessary, so we must implement /// this ourselves. @@ -51,7 +51,7 @@ pub extern "C" fn truncf64(x: f64) -> f64 { x.trunc() } -/// `f64.round()` doesn't have the correct behavior. Ideally, we'd use +/// `f64.round()` doesn't have the correct behavior. Ideally, we'd use /// "https://doc.rust-lang.org/std/intrinsics/fn.nearbyintf64.html" for this, /// but support for stable compilers is necessary, so we must implement /// this ourselves. diff --git a/lib/clif-backend/src/resolver.rs b/lib/clif-backend/src/resolver.rs index 96c2aa610..d5eb3d78d 100644 --- a/lib/clif-backend/src/resolver.rs +++ b/lib/clif-backend/src/resolver.rs @@ -1,5 +1,6 @@ use crate::libcalls; use crate::relocation::{Reloc, RelocSink, Relocation, RelocationType, TrapSink}; +use byteorder::{ByteOrder, LittleEndian}; use cranelift_codegen::{ir, isa, Context}; use std::mem; use std::ptr::{write_unaligned, NonNull}; @@ -9,7 +10,6 @@ use wasmer_runtime::{ types::{FuncIndex, Map, MapIndex}, vm, vmcalls, }; -use byteorder::{LittleEndian, ByteOrder}; #[allow(dead_code)] pub struct FuncResolverBuilder { @@ -127,13 +127,11 @@ impl FuncResolverBuilder { .unwrap(); let empty_space_offset = self.resolver.map[index] + reloc.offset as usize; let ptr_slice = unsafe { - &mut self.resolver.memory.as_slice_mut()[empty_space_offset..empty_space_offset+8] + &mut self.resolver.memory.as_slice_mut() + [empty_space_offset..empty_space_offset + 8] }; - LittleEndian::write_u64( - ptr_slice, - ptr_to_write, - ); - }, + LittleEndian::write_u64(ptr_slice, ptr_to_write); + } Reloc::X86PCRel4 => unsafe { let reloc_address = func_addr.offset(reloc.offset as isize) as isize; let reloc_addend = reloc.addend as isize; @@ -177,7 +175,11 @@ impl FuncResolver { // Implements FuncResolver trait. impl backend::FuncResolver for FuncResolver { - fn get(&self, _module: &wasmer_runtime::module::Module, index: FuncIndex) -> Option> { + fn get( + &self, + _module: &wasmer_runtime::module::Module, + index: FuncIndex, + ) -> Option> { self.lookup(index) } } @@ -185,4 +187,4 @@ impl backend::FuncResolver for FuncResolver { #[inline] fn round_up(n: usize, multiple: usize) -> usize { (n + multiple - 1) & !(multiple - 1) -} \ No newline at end of file +} diff --git a/lib/runtime/build/mod.rs b/lib/runtime/build/mod.rs index c894cf0be..7e411f00a 100644 --- a/lib/runtime/build/mod.rs +++ b/lib/runtime/build/mod.rs @@ -8,4 +8,4 @@ fn main() { if env::var(SPECTESTS_ENV_VAR).unwrap_or("0".to_string()) == "1" { spectests::build(); } -} \ No newline at end of file +} diff --git a/lib/runtime/build/spectests.rs b/lib/runtime/build/spectests.rs index 57fb7411d..88f5db79e 100644 --- a/lib/runtime/build/spectests.rs +++ b/lib/runtime/build/spectests.rs @@ -211,7 +211,7 @@ use wasmer_runtime::{{Instance, module::Module}}; use wasmer_clif_backend::CraneliftCompiler; use crate::spectests::_common::{{ - spectest_importobject, + generate_imports, NaNCheck, }};\n\n", self.filename @@ -272,7 +272,7 @@ fn test_module_{}() {{ let module_str = \"{}\"; let wasm_binary = wat2wasm(module_str.as_bytes()).expect(\"WAST not valid or malformed\"); let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect(\"WASM can't be compiled\"); - module.instantiate(&spectest_importobject()).expect(\"WASM can't be instantiated\") + module.instantiate(generate_imports()).expect(\"WASM can't be instantiated\") }}\n", self.last_module, // We do this to ident four spaces, so it looks aligned to the function body @@ -334,11 +334,13 @@ fn {}_assert_invalid() {{ } => { // let return_type = wabt2rust_type(&args[0]); // let func_return = format!(" -> {}", return_type); - let assertion = String::from("assert!(match result { + let assertion = String::from( + "assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), _ => unimplemented!() - })"); + })", + ); // We map the arguments provided into the raw Arguments provided // to libffi @@ -391,11 +393,13 @@ fn {}_assert_invalid() {{ _ => wabt2rust_type(&args[0]), }; // let func_return = format!(" -> {}", return_type); - let assertion = String::from("assert!(match result { + let assertion = String::from( + "assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), _ => unimplemented!() - })"); + })", + ); // We map the arguments provided into the raw Arguments provided // to libffi @@ -527,10 +531,10 @@ fn {}_assert_malformed() {{ {assertion} result.map(|_| ()) }}\n", - func_name=func_name, - field=field, - args_values=args_values.join(", "), - assertion=assertion, + func_name = func_name, + field = field, + args_values = args_values.join(", "), + assertion = assertion, ) .as_str(), ); diff --git a/lib/runtime/examples/simple/main.rs b/lib/runtime/examples/simple/main.rs index 1aeb9aef6..b8f6a6a3d 100644 --- a/lib/runtime/examples/simple/main.rs +++ b/lib/runtime/examples/simple/main.rs @@ -1,32 +1,44 @@ +use std::rc::Rc; +use wabt::wat2wasm; use wasmer_clif_backend::CraneliftCompiler; use wasmer_runtime::{ self as runtime, + export::{Context, Export}, + import::Imports, types::{FuncSig, Type, Value}, - vm, Import, Imports, FuncRef, + vm, FuncRef, }; static EXAMPLE_WASM: &'static [u8] = include_bytes!("simple.wasm"); fn main() -> Result<(), String> { - let module = runtime::compile(EXAMPLE_WASM, &CraneliftCompiler::new())?; + let wasm_binary = wat2wasm(IMPORT_MODULE.as_bytes()).expect("WAST not valid or malformed"); + let inner_module = runtime::compile(&wasm_binary, &CraneliftCompiler::new())?; let mut imports = Imports::new(); - imports.add( + imports.register_export( "env", - "print_num", - Import::Func( - unsafe { FuncRef::new(print_num as _) }, - FuncSig { + "print_i32", + Export::Function { + func: unsafe { FuncRef::new(print_num as _) }, + ctx: Context::Internal, + signature: FuncSig { params: vec![Type::I32], returns: vec![Type::I32], }, - ), + }, ); - let mut instance = module.instantiate(&imports)?; + let imports = Rc::new(imports); - let ret = instance.call("main", &[Value::I32(42)])?; + let inner_instance = inner_module.instantiate(imports)?; + let mut outer_imports = Imports::new(); + outer_imports.register_instance("env", inner_instance); + let outer_imports = Rc::new(outer_imports); + let outer_module = runtime::compile(EXAMPLE_WASM, &CraneliftCompiler::new())?; + let mut outer_instance = outer_module.instantiate(outer_imports)?; + let ret = outer_instance.call("main", &[Value::I32(42)])?; println!("ret: {:?}", ret); Ok(()) @@ -36,3 +48,24 @@ extern "C" fn print_num(n: i32, _vmctx: *mut vm::Ctx) -> i32 { println!("print_num({})", n); n + 1 } + +static IMPORT_MODULE: &str = r#" +(module + (type $t0 (func (param i32) (result i32))) + (import "env" "print_i32" (func $print_i32 (type $t0))) + (func $print_num (export "print_num") (type $t0) (param $p0 i32) (result i32) + get_local $p0 + call $print_i32)) +"#; + +fn generate_imports() -> Rc { + let wasm_binary = wat2wasm(IMPORT_MODULE.as_bytes()).expect("WAST not valid or malformed"); + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + let instance = module + .instantiate(Rc::new(Imports::new())) + .expect("WASM can't be instantiated"); + let mut imports = Imports::new(); + imports.register_instance("env", instance); + Rc::new(imports) +} diff --git a/lib/runtime/examples/test.rs b/lib/runtime/examples/test.rs index dd3ce56b7..6c4e021ca 100644 --- a/lib/runtime/examples/test.rs +++ b/lib/runtime/examples/test.rs @@ -1,75 +1,46 @@ +use std::rc::Rc; use wabt::wat2wasm; -use wasmer_runtime::{Instance, Imports, Import, FuncRef, table::TableBacking, types::{Value, Type, Table, FuncSig, ElementType}, module::Module}; -use std::sync::Arc; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::{ + export::{Context, Export}, + import::Imports, + module::Module, + table::TableBacking, + types::{ElementType, FuncSig, Table, Type, Value}, + FuncRef, Instance, +}; fn main() { let mut instance = create_module_1(); - let result = instance.call("signature-implicit-reused", &[]); + let result = instance.call("type-i64", &[]); println!("result: {:?}", result); } +fn generate_imports() -> Rc { + // let wasm_binary = wat2wasm(IMPORT_MODULE.as_bytes()).expect("WAST not valid or malformed"); + // let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); + // let instance = module.instantiate(Rc::new(Imports::new())).expect("WASM can't be instantiated"); + let imports = Imports::new(); + // imports.register_instance("spectest", instance); + Rc::new(imports) +} + fn create_module_1() -> Box { let module_str = "(module - (import \"spectest\" \"memory\" (memory (;0;) 0)) - (data (;0;) (i32.const 0) \"\")) + (type (;0;) (func (result i64))) + (func (;0;) (type 0) (result i64) + i64.const 356) + (func (;1;) (type 0) (result i64) + i32.const 1 + call_indirect (type 0)) + (table (;0;) 2 anyfunc) + (export \"type-i64\" (func 1)) + (elem (;0;) (i32.const 0) 0 1)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } - -extern "C" fn print_i32(num: i32) { - println!("{}", num); -} - -extern "C" fn print() {} - -static GLOBAL_I32: i32 = 666; - -pub fn spectest_importobject() -> Imports { - let mut import_object = Imports::new(); - - import_object.add( - "spectest", - "print_i32", - Import::Func( - unsafe { FuncRef::new(print_i32 as _) }, - FuncSig { - params: vec![Type::I32], - returns: vec![], - }, - ), - ); - - import_object.add( - "spectest", - "print", - Import::Func( - unsafe { FuncRef::new(print as _) }, - FuncSig { - params: vec![], - returns: vec![], - }, - ), - ); - - import_object.add( - "spectest".to_string(), - "global_i32".to_string(), - Import::Global(Value::I64(GLOBAL_I32 as _)), - ); - - let table = Table { - ty: ElementType::Anyfunc, - min: 0, - max: Some(30), - }; - import_object.add( - "spectest".to_string(), - "table".to_string(), - Import::Table(Arc::new(TableBacking::new(&table)), table), - ); - - return import_object; -} \ No newline at end of file diff --git a/lib/runtime/src/backend.rs b/lib/runtime/src/backend.rs index ed51ea543..887e4e7ee 100644 --- a/lib/runtime/src/backend.rs +++ b/lib/runtime/src/backend.rs @@ -1,8 +1,8 @@ use crate::{module::Module, types::FuncIndex, vm}; use std::ptr::NonNull; -pub use crate::sig_registry::SigRegistry; pub use crate::mmap::{Mmap, Protect}; +pub use crate::sig_registry::SigRegistry; pub trait Compiler { /// Compiles a `Module` from WebAssembly binary format diff --git a/lib/runtime/src/backing.rs b/lib/runtime/src/backing.rs index 270de479a..6305d17ea 100644 --- a/lib/runtime/src/backing.rs +++ b/lib/runtime/src/backing.rs @@ -1,5 +1,6 @@ use crate::{ - instance::{Import, ImportResolver}, + export::{Context, Export}, + import::ImportResolver, memory::LinearMemory, module::{ImportName, Module}, table::{TableBacking, TableElements}, @@ -18,13 +19,13 @@ pub struct LocalBacking { } impl LocalBacking { - pub fn new(module: &Module, imports: &ImportBacking) -> Self { + pub fn new(module: &Module, imports: &ImportBacking, vmctx: *mut vm::Ctx) -> Self { let mut memories = Self::generate_memories(module); let mut tables = Self::generate_tables(module); let globals = Self::generate_globals(module); let vm_memories = Self::finalize_memories(module, &mut memories[..]); - let vm_tables = Self::finalize_tables(module, imports, &mut tables[..]); + let vm_tables = Self::finalize_tables(module, imports, &mut tables[..], vmctx); let vm_globals = Self::finalize_globals(module, imports, globals); Self { @@ -61,9 +62,7 @@ impl LocalBacking { fn finalize_memories(module: &Module, memories: &mut [LinearMemory]) -> Box<[vm::LocalMemory]> { for init in &module.data_initializers { assert!(init.base.is_none(), "global base not supported yet"); - assert!( - init.offset + init.data.len() <= memories[init.memory_index.index()].size() - ); + assert!(init.offset + init.data.len() <= memories[init.memory_index.index()].size()); let offset = init.offset; let mem: &mut LinearMemory = &mut memories[init.memory_index.index()]; // let end_of_init = offset + init.data.len(); @@ -98,6 +97,7 @@ impl LocalBacking { module: &Module, imports: &ImportBacking, tables: &mut [TableBacking], + vmctx: *mut vm::Ctx, ) -> Box<[vm::LocalTable]> { for init in &module.table_initializers { assert!(init.base.is_none(), "global base not supported yet"); @@ -106,7 +106,8 @@ impl LocalBacking { TableElements::Anyfunc(ref mut elements) => { for (i, &func_index) in init.elements.iter().enumerate() { let sig_index = module.func_assoc[func_index]; - let vm_sig_id = vm::SigId(sig_index.index() as u32); + let sig_id = vm::SigId(sig_index.index() as u32); + let func_data = if module.is_imported_function(func_index) { imports.functions[func_index.index()].clone() } else { @@ -116,13 +117,13 @@ impl LocalBacking { .get(module, func_index) .unwrap() .as_ptr(), + vmctx, } }; - elements[init.offset + i] = vm::Anyfunc { - func_data, - sig_id: vm_sig_id, - }; + println!("func_data: {:#?}", func_data); + + elements[init.offset + i] = vm::Anyfunc { func_data, sig_id }; } } } @@ -152,7 +153,9 @@ impl LocalBacking { Initializer::Const(Value::I64(x)) => x as u64, Initializer::Const(Value::F32(x)) => x.to_bits() as u64, Initializer::Const(Value::F64(x)) => x.to_bits(), - Initializer::GetGlobal(index) => (imports.globals[index.index()].global).data, + Initializer::GetGlobal(index) => unsafe { + (*imports.globals[index.index()].global).data + }, }; } @@ -169,7 +172,11 @@ pub struct ImportBacking { } impl ImportBacking { - pub fn new(module: &Module, imports: &dyn ImportResolver) -> Result { + pub fn new( + module: &Module, + imports: &dyn ImportResolver, + vmctx: *mut vm::Ctx, + ) -> Result { assert!( module.imported_memories.len() == 0, "imported memories not yet supported" @@ -180,7 +187,7 @@ impl ImportBacking { ); Ok(ImportBacking { - functions: import_functions(module, imports)?, + functions: import_functions(module, imports, vmctx)?, memories: vec![].into_boxed_slice(), tables: vec![].into_boxed_slice(), globals: import_globals(module, imports)?, @@ -192,89 +199,71 @@ impl ImportBacking { // } -fn import_functions(module: &Module, imports: &dyn ImportResolver) -> Result, String> { +fn import_functions( + module: &Module, + imports: &dyn ImportResolver, + vmctx: *mut vm::Ctx, +) -> Result, String> { let mut functions = Vec::with_capacity(module.imported_functions.len()); - for ( - index, - ImportName { - module: mod_name, - name: item_name, - }, - ) in &module.imported_functions - { + for (index, ImportName { namespace, name }) in &module.imported_functions { let sig_index = module.func_assoc[index]; let expected_sig = module.sig_registry.lookup_func_sig(sig_index); - let import = imports.get(mod_name, item_name); + let import = imports.get(namespace, name); match import { - Some(&Import::Func(ref func, ref signature)) => { - if expected_sig == signature { + Some(Export::Function { + func, + ctx, + signature, + }) => { + if expected_sig == &signature { functions.push(vm::ImportedFunc { func: func.inner(), - // vmctx: ptr::null_mut(), + vmctx: match ctx { + Context::External(ctx) => ctx, + Context::Internal => vmctx, + }, }); } else { return Err(format!( "unexpected signature for {:?}:{:?}", - mod_name, item_name + namespace, name )); } } Some(_) => { - return Err(format!( - "incorrect import type for {}:{}", - mod_name, item_name - )); + return Err(format!("incorrect import type for {}:{}", namespace, name)); } None => { - return Err(format!("import not found: {}:{}", mod_name, item_name)); + return Err(format!("import not found: {}:{}", namespace, name)); } } } Ok(functions.into_boxed_slice()) } -fn import_globals(module: &Module, imports: &dyn ImportResolver) -> Result, String> { +fn import_globals( + module: &Module, + imports: &dyn ImportResolver, +) -> Result, String> { let mut globals = Vec::with_capacity(module.imported_globals.len()); - for ( - _, - ( - ImportName { - module: mod_name, - name: item_name, - }, - global_desc, - ), - ) in &module.imported_globals - { - let import = imports.get(mod_name, item_name); + for (_, (ImportName { namespace, name }, global_desc)) in &module.imported_globals { + let import = imports.get(namespace, name); match import { - Some(Import::Global(val)) => { - if val.ty() == global_desc.ty { - globals.push(vm::ImportedGlobal { - global: vm::LocalGlobal { - data: match val { - Value::I32(n) => *n as u64, - Value::I64(n) => *n as u64, - Value::F32(n) => (*n).to_bits() as u64, - Value::F64(n) => (*n).to_bits(), - }, - }, - }); + Some(Export::Global { local, global }) => { + if &global == global_desc { + globals.push(vm::ImportedGlobal { global: local }); } else { return Err(format!( - "unexpected global type for {:?}:{:?}", - mod_name, item_name + "unexpected global description for {:?}:{:?}", + namespace, name )); } } Some(_) => { - return Err(format!( - "incorrect import type for {}:{}", - mod_name, item_name - )); + return Err(format!("incorrect import type for {}:{}", namespace, name)); } None => { - return Err(format!("import not found: {}:{}", mod_name, item_name)); + return Err(format!("import not found: {}:{}", namespace, name)); } } } diff --git a/lib/runtime/src/export.rs b/lib/runtime/src/export.rs new file mode 100644 index 000000000..a99327e8c --- /dev/null +++ b/lib/runtime/src/export.rs @@ -0,0 +1,34 @@ +use crate::{ + instance::FuncRef, + types::{FuncSig, GlobalDesc, Memory, Table}, + vm, +}; + +#[derive(Debug, Clone)] +pub enum Context { + External(*mut vm::Ctx), + Internal, +} + +#[derive(Debug, Clone)] +pub enum Export { + Function { + func: FuncRef, + ctx: Context, + signature: FuncSig, + }, + Memory { + local: *mut vm::LocalMemory, + ctx: Context, + memory: Memory, + }, + Table { + local: *mut vm::LocalTable, + ctx: Context, + table: Table, + }, + Global { + local: *mut vm::LocalGlobal, + global: GlobalDesc, + }, +} diff --git a/lib/runtime/src/import.rs b/lib/runtime/src/import.rs new file mode 100644 index 000000000..75c1ef764 --- /dev/null +++ b/lib/runtime/src/import.rs @@ -0,0 +1,58 @@ +use crate::{export::Export, Instance}; +use hashbrown::{hash_map::Entry, HashMap}; + +pub trait ImportResolver { + fn get(&self, namespace: &str, name: &str) -> Option; +} + +enum Namespace { + Instance(Box), + UserSupplied(HashMap), +} + +pub struct Imports { + map: HashMap, +} + +impl Imports { + pub fn new() -> Self { + Self { + map: HashMap::new(), + } + } + + pub fn register_instance(&mut self, namespace: impl Into, instance: Box) { + match self.map.entry(namespace.into()) { + Entry::Vacant(empty) => empty.insert(Namespace::Instance(instance)), + Entry::Occupied(_) => { + panic!("cannot register an instance in a namespace that already exists") + } + }; + } + + pub fn register_export( + &mut self, + namespace: impl Into, + name: impl Into, + export: Export, + ) { + let namespace_item = self + .map + .entry(namespace.into()) + .or_insert_with(|| Namespace::UserSupplied(HashMap::new())); + + match namespace_item { + Namespace::UserSupplied(ref mut map) => map.insert(name.into(), export), + Namespace::Instance(_) => panic!("cannot register an export in a namespace that has already been used to register an instance"), + }; + } +} + +impl ImportResolver for Imports { + fn get(&self, namespace: &str, name: &str) -> Option { + match self.map.get(namespace)? { + Namespace::UserSupplied(map) => map.get(name).cloned(), + Namespace::Instance(instance) => instance.get_export(name).ok(), + } + } +} diff --git a/lib/runtime/src/instance.rs b/lib/runtime/src/instance.rs index 79e128ac5..43076f156 100644 --- a/lib/runtime/src/instance.rs +++ b/lib/runtime/src/instance.rs @@ -1,40 +1,54 @@ use crate::recovery::call_protected; use crate::{ backing::{ImportBacking, LocalBacking}, - memory::LinearMemory, - module::{Export, Module}, - table::TableBacking, - types::{FuncIndex, FuncSig, Memory, Table, Type, Value, MapIndex}, + export::{Context, Export}, + import::ImportResolver, + module::{ExportIndex, Module}, + types::{FuncIndex, FuncSig, MapIndex, Type, Value}, vm, }; -use hashbrown::HashMap; +use hashbrown::hash_map; use libffi::high::{arg as libffi_arg, call as libffi_call, CodePtr}; -use std::iter; -use std::sync::Arc; +use std::rc::Rc; +use std::{iter, mem}; pub struct Instance { - pub(crate) backing: LocalBacking, - import_backing: ImportBacking, pub module: Module, + #[allow(dead_code)] + pub(crate) backing: LocalBacking, + #[allow(dead_code)] + imports: Rc, + import_backing: ImportBacking, + vmctx: Box, } impl Instance { pub(crate) fn new( module: Module, - imports: &dyn ImportResolver, + imports: Rc, ) -> Result, String> { - let import_backing = ImportBacking::new(&module, imports)?; - let backing = LocalBacking::new(&module, &import_backing); + // We need the backing and import_backing to create a vm::Ctx, but we need + // a vm::Ctx to create a backing and an import_backing. The solution is to create an + // uninitialized vm::Ctx and then initialize it in-place. + let mut vmctx = unsafe { Box::new(mem::uninitialized()) }; - let start_func = module.start_func; + let import_backing = ImportBacking::new(&module, &*imports, &mut *vmctx)?; + let backing = LocalBacking::new(&module, &import_backing, &mut *vmctx); + // When Pin is stablized, this will use `Box::pinned` instead of `Box::new`. let mut instance = Box::new(Instance { - backing, - import_backing, module, + backing, + imports, + import_backing, + vmctx, }); - if let Some(start_index) = start_func { + // Initialize the vm::Ctx in-place after the import_backing + // has been boxed. + *instance.vmctx = vm::Ctx::new(&mut instance.backing, &mut instance.import_backing); + + if let Some(start_index) = instance.module.start_func { instance.call_with_index(start_index, &[])?; } @@ -48,15 +62,17 @@ impl Instance { /// This will eventually return `Result>, String>` in /// order to support multi-value returns. pub fn call(&mut self, name: &str, args: &[Value]) -> Result, String> { - let func_index = *self + let export_index = self .module .exports .get(name) - .ok_or_else(|| "there is no export with that name".to_string()) - .and_then(|export| match export { - Export::Func(func_index) => Ok(func_index), - _ => Err("that export is not a function".to_string()), - })?; + .ok_or_else(|| format!("there is no export with that name: {}", name))?; + + let func_index = if let ExportIndex::Func(func_index) = export_index { + *func_index + } else { + return Err("that export is not a function".to_string()); + }; self.call_with_index(func_index, args) } @@ -66,31 +82,25 @@ impl Instance { func_index: FuncIndex, args: &[Value], ) -> Result, String> { - // Check the function signature. - let sig_index = *self - .module - .func_assoc - .get(func_index) - .expect("broken invariant, incorrect func index"); - - { - let signature = self.module.sig_registry.lookup_func_sig(sig_index); + let (func_ref, ctx, signature) = self.get_func_from_index(func_index); - assert!( - signature.returns.len() <= 1, - "multi-value returns not yet supported" - ); + println!("func_ref: {:?}", func_ref); - if !signature.check_sig(args) { - return Err("incorrect signature".to_string()); - } + let func_ptr = CodePtr::from_ptr(func_ref.inner() as _); + let vmctx_ptr = match ctx { + Context::External(vmctx) => vmctx, + Context::Internal => &mut *self.vmctx, + }; + + assert!( + signature.returns.len() <= 1, + "multi-value returns not yet supported" + ); + + if !signature.check_sig(args) { + return Err("incorrect signature".to_string()); } - // the vmctx will be located at the same place on the stack the entire time that this - // wasm function is running. - let mut vmctx = vm::Ctx::new(&mut self.backing, &mut self.import_backing); - let vmctx_ptr = &mut vmctx as *mut vm::Ctx; - let libffi_args: Vec<_> = args .iter() .map(|val| match val { @@ -102,22 +112,8 @@ impl Instance { .chain(iter::once(libffi_arg(&vmctx_ptr))) .collect(); - let func_ptr = CodePtr::from_ptr(if self.module.is_imported_function(func_index) { - let imported_func = &self.import_backing.functions[func_index.index()]; - imported_func.func as *const _ - } else { - self.module - .func_resolver - .get(&self.module, func_index) - .expect("broken invariant, func resolver not synced with module.exports") - .cast() - .as_ptr() - }); - call_protected(|| { - self.module - .sig_registry - .lookup_func_sig(sig_index) + signature .returns .first() .map(|ty| match ty { @@ -135,9 +131,75 @@ impl Instance { }) }) } + + pub fn get_export(&self, name: &str) -> Result { + let export_index = self + .module + .exports + .get(name) + .ok_or_else(|| format!("there is no export with that name: {}", name))?; + + Ok(self.get_export_from_index(export_index)) + } + + pub fn exports(&self) -> ExportIter { + ExportIter::new(self) + } + + fn get_export_from_index(&self, export_index: &ExportIndex) -> Export { + match export_index { + ExportIndex::Func(func_index) => { + let (func, ctx, signature) = self.get_func_from_index(*func_index); + + Export::Function { + func, + ctx: match ctx { + Context::Internal => { + Context::External(&*self.vmctx as *const vm::Ctx as *mut vm::Ctx) + } + ctx @ Context::External(_) => ctx, + }, + signature, + } + } + ExportIndex::Memory(_memory_index) => unimplemented!(), + ExportIndex::Global(_global_index) => unimplemented!(), + ExportIndex::Table(_table_index) => unimplemented!(), + } + } + + fn get_func_from_index(&self, func_index: FuncIndex) -> (FuncRef, Context, FuncSig) { + let sig_index = *self + .module + .func_assoc + .get(func_index) + .expect("broken invariant, incorrect func index"); + + let (func_ptr, ctx) = if self.module.is_imported_function(func_index) { + let imported_func = &self.import_backing.functions[func_index.index()]; + ( + imported_func.func as *const _, + Context::External(imported_func.vmctx), + ) + } else { + ( + self.module + .func_resolver + .get(&self.module, func_index) + .expect("broken invariant, func resolver not synced with module.exports") + .cast() + .as_ptr() as *const _, + Context::Internal, + ) + }; + + let signature = self.module.sig_registry.lookup_func_sig(sig_index).clone(); + + (FuncRef(func_ptr), ctx, signature) + } } -#[derive(Debug)] +#[derive(Debug, Clone)] pub struct FuncRef(*const vm::Func); impl FuncRef { @@ -153,47 +215,31 @@ impl FuncRef { } } -#[derive(Debug)] -pub enum Import { - Func(FuncRef, FuncSig), - Table(Arc, Table), - Memory(Arc, Memory), - Global(Value), +pub struct ExportIter<'a> { + instance: &'a Instance, + iter: hash_map::Iter<'a, String, ExportIndex>, } -pub struct Imports { - map: HashMap>, -} - -impl Imports { - pub fn new() -> Self { +impl<'a> ExportIter<'a> { + fn new(instance: &'a Instance) -> Self { Self { - map: HashMap::new(), + instance, + iter: instance.module.exports.iter(), } } - - pub fn add(&mut self, module: impl Into, name: impl Into, import: Import) { - self.map - .entry(module.into()) - .or_insert_with(|| HashMap::new()) - .insert(name.into(), import); - } - - pub fn get(&self, module: &str, name: &str) -> Option<&Import> { - self.map.get(module).and_then(|m| m.get(name)) - } } -impl ImportResolver for Imports { - fn get(&self, module: &str, name: &str) -> Option<&Import> { - self.get(module, name) +impl<'a> Iterator for ExportIter<'a> { + type Item = (String, Export); + fn next(&mut self) -> Option<(String, Export)> { + let (name, export_index) = self.iter.next()?; + Some(( + name.clone(), + self.instance.get_export_from_index(export_index), + )) } } -pub trait ImportResolver { - fn get(&self, module: &str, name: &str) -> Option<&Import>; -} - // TODO Remove this later, only needed for compilation till emscripten is updated impl Instance { pub fn memory_offset_addr(&self, _index: usize, _offset: usize) -> *const usize { diff --git a/lib/runtime/src/lib.rs b/lib/runtime/src/lib.rs index 230cbf8a6..4f8be99e7 100644 --- a/lib/runtime/src/lib.rs +++ b/lib/runtime/src/lib.rs @@ -4,21 +4,23 @@ extern crate field_offset; #[macro_use] mod macros; +pub mod backend; mod backing; +pub mod export; +pub mod import; mod instance; mod memory; -mod recovery; -mod sighandler; -mod sig_registry; mod mmap; pub mod module; -pub mod backend; +mod recovery; +mod sig_registry; +mod sighandler; pub mod table; pub mod types; pub mod vm; pub mod vmcalls; -pub use self::instance::{Import, ImportResolver, Imports, FuncRef, Instance}; +pub use self::instance::{FuncRef, Instance}; pub use self::memory::LinearMemory; /// Compile a webassembly module using the provided compiler. diff --git a/lib/runtime/src/memory.rs b/lib/runtime/src/memory.rs index 6afe4468b..ed0a309b4 100644 --- a/lib/runtime/src/memory.rs +++ b/lib/runtime/src/memory.rs @@ -52,21 +52,22 @@ impl LinearMemory { assert!(mem.max.is_none() || mem.max.unwrap() <= Self::MAX_PAGES); debug!("Instantiate LinearMemory(mem: {:?})", mem); - let (mmap_size, initial_pages, offset_guard_size, requires_signal_catch) = - if /*mem.is_static_heap()*/ true { - (Self::DEFAULT_SIZE, mem.min, Self::DEFAULT_GUARD_SIZE, true) - // This is a static heap - } else { - // this is a dynamic heap - assert!(!mem.shared, "shared memories must have a maximum size."); + let (mmap_size, initial_pages, offset_guard_size, requires_signal_catch) = if + /*mem.is_static_heap()*/ + true { + (Self::DEFAULT_SIZE, mem.min, Self::DEFAULT_GUARD_SIZE, true) + // This is a static heap + } else { + // this is a dynamic heap + assert!(!mem.shared, "shared memories must have a maximum size."); - ( - mem.min as usize * Self::PAGE_SIZE as usize, - mem.min, - 0, - false, - ) - }; + ( + mem.min as usize * Self::PAGE_SIZE as usize, + mem.min, + 0, + false, + ) + }; let mut mmap = Mmap::with_size(mmap_size).unwrap(); diff --git a/lib/runtime/src/module.rs b/lib/runtime/src/module.rs index fe4789ba0..31c086425 100644 --- a/lib/runtime/src/module.rs +++ b/lib/runtime/src/module.rs @@ -1,15 +1,16 @@ use crate::{ backend::FuncResolver, + import::ImportResolver, sig_registry::SigRegistry, types::{ FuncIndex, Global, GlobalDesc, GlobalIndex, Map, MapIndex, Memory, MemoryIndex, SigIndex, Table, TableIndex, }, - ImportResolver, Instance, + Instance, }; use hashbrown::HashMap; use std::ops::Deref; -use std::sync::Arc; +use std::rc::Rc; /// This is used to instantiate a new webassembly module. pub struct ModuleInner { @@ -23,7 +24,7 @@ pub struct ModuleInner { pub imported_tables: Map, pub imported_globals: Map, - pub exports: HashMap, + pub exports: HashMap, pub data_initializers: Vec, pub table_initializers: Vec, @@ -33,17 +34,17 @@ pub struct ModuleInner { pub sig_registry: SigRegistry, } -pub struct Module(Arc); +pub struct Module(Rc); impl Module { #[inline] pub fn new(inner: ModuleInner) -> Self { - Module(Arc::new(inner)) + Module(Rc::new(inner)) } /// Instantiate a webassembly module with the provided imports. - pub fn instantiate(&self, imports: &dyn ImportResolver) -> Result, String> { - Instance::new(Module(Arc::clone(&self.0)), imports) + pub fn instantiate(&self, imports: Rc) -> Result, String> { + Instance::new(Module(Rc::clone(&self.0)), imports) } } @@ -63,21 +64,21 @@ impl Deref for Module { #[derive(Debug, Clone)] pub struct ImportName { - pub module: String, + pub namespace: String, pub name: String, } impl From<(String, String)> for ImportName { fn from(n: (String, String)) -> Self { ImportName { - module: n.0, + namespace: n.0, name: n.1, } } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum Export { +pub enum ExportIndex { Func(FuncIndex), Memory(MemoryIndex), Global(GlobalIndex), diff --git a/lib/runtime/src/sig_registry.rs b/lib/runtime/src/sig_registry.rs index 268c2a1e7..9442ab5c1 100644 --- a/lib/runtime/src/sig_registry.rs +++ b/lib/runtime/src/sig_registry.rs @@ -1,6 +1,4 @@ -use crate::{ - types::{FuncSig, Map, SigIndex}, -}; +use crate::types::{FuncSig, Map, SigIndex}; use hashbrown::HashMap; #[derive(Debug)] diff --git a/lib/runtime/src/types.rs b/lib/runtime/src/types.rs index 57a15e0e5..94a8027c1 100644 --- a/lib/runtime/src/types.rs +++ b/lib/runtime/src/types.rs @@ -1,9 +1,8 @@ use std::marker::PhantomData; use std::{ - iter, + iter, mem, ops::{Index, IndexMut}, slice, - mem, }; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] @@ -354,7 +353,7 @@ impl MonoVec { 0 | 1 => Self::new(), _ => Self { inner: MonoVecInner::Heap(Vec::with_capacity(capacity)), - } + }, } } @@ -362,16 +361,12 @@ impl MonoVec { let uninit = unsafe { mem::uninitialized() }; let prev = mem::replace(&mut self.inner, uninit); let next = match prev { - MonoVecInner::None => { - MonoVecInner::Inline(item) - }, - MonoVecInner::Inline(previous_item) => { - MonoVecInner::Heap(vec![previous_item, item]) - }, + MonoVecInner::None => MonoVecInner::Inline(item), + MonoVecInner::Inline(previous_item) => MonoVecInner::Heap(vec![previous_item, item]), MonoVecInner::Heap(mut v) => { v.push(item); MonoVecInner::Heap(v) - }, + } }; let uninit = mem::replace(&mut self.inner, next); mem::forget(uninit); @@ -379,51 +374,35 @@ impl MonoVec { pub fn pop(&mut self) -> Option { match self.inner { - MonoVecInner::None => { - None - }, + MonoVecInner::None => None, MonoVecInner::Inline(ref mut item) => { let uninit = unsafe { mem::uninitialized() }; let item = mem::replace(item, uninit); let uninit = mem::replace(&mut self.inner, MonoVecInner::None); mem::forget(uninit); Some(item) - }, - MonoVecInner::Heap(ref mut v) => { - v.pop() - }, + } + MonoVecInner::Heap(ref mut v) => v.pop(), } } pub fn as_slice(&self) -> &[T] { match self.inner { - MonoVecInner::None => { - unsafe { - slice::from_raw_parts(mem::align_of::() as *const T, 0) - } - }, - MonoVecInner::Inline(ref item) => { - slice::from_ref(item) - }, - MonoVecInner::Heap(ref v) => { - &v[..] + MonoVecInner::None => unsafe { + slice::from_raw_parts(mem::align_of::() as *const T, 0) }, + MonoVecInner::Inline(ref item) => slice::from_ref(item), + MonoVecInner::Heap(ref v) => &v[..], } } pub fn as_slice_mut(&mut self) -> &mut [T] { match self.inner { - MonoVecInner::None => { - unsafe { - slice::from_raw_parts_mut(mem::align_of::() as *mut T, 0) - } - }, - MonoVecInner::Inline(ref mut item) => { - slice::from_mut(item) - }, - MonoVecInner::Heap(ref mut v) => { - &mut v[..] + MonoVecInner::None => unsafe { + slice::from_raw_parts_mut(mem::align_of::() as *mut T, 0) }, + MonoVecInner::Inline(ref mut item) => slice::from_mut(item), + MonoVecInner::Heap(ref mut v) => &mut v[..], } } -} \ No newline at end of file +} diff --git a/lib/runtime/src/vm.rs b/lib/runtime/src/vm.rs index afb3555ac..7cce7dbf3 100644 --- a/lib/runtime/src/vm.rs +++ b/lib/runtime/src/vm.rs @@ -40,7 +40,7 @@ impl Ctx { imported_tables: import_backing.tables.as_mut_ptr(), imported_globals: import_backing.globals.as_mut_ptr(), imported_funcs: import_backing.functions.as_mut_ptr(), - + local_backing, } } @@ -88,6 +88,7 @@ pub enum Func {} #[repr(C)] pub struct ImportedFunc { pub func: *const Func, + pub vmctx: *mut Ctx, } impl ImportedFunc { @@ -95,6 +96,10 @@ impl ImportedFunc { 0 * (mem::size_of::() as u8) } + pub fn offset_vmctx() -> u8 { + 1 * (mem::size_of::() as u8) + } + pub fn size() -> u8 { mem::size_of::() as u8 } @@ -164,12 +169,17 @@ impl LocalMemory { pub struct ImportedMemory { /// A pointer to the memory definition. pub memory: *mut LocalMemory, + pub vmctx: *mut Ctx, } impl ImportedMemory { pub fn offset_memory() -> u8 { 0 * (mem::size_of::() as u8) } + + pub fn offset_vmctx() -> u8 { + 1 * (mem::size_of::() as u8) + } } /// Definition of a global used by the VM. @@ -192,11 +202,11 @@ impl LocalGlobal { #[derive(Debug, Clone)] #[repr(C)] pub struct ImportedGlobal { - pub global: LocalGlobal, + pub global: *mut LocalGlobal, } impl ImportedGlobal { - pub fn offset_data() -> u8 { + pub fn offset_global() -> u8 { 0 * (mem::size_of::() as u8) } } @@ -216,7 +226,10 @@ pub struct Anyfunc { impl Anyfunc { pub fn null() -> Self { Self { - func_data: ImportedFunc { func: ptr::null() }, + func_data: ImportedFunc { + func: ptr::null(), + vmctx: ptr::null_mut(), + }, sig_id: SigId(u32::max_value()), } } @@ -225,12 +238,12 @@ impl Anyfunc { 0 * (mem::size_of::() as u8) } - // pub fn offset_vmctx() -> u8 { - // 1 * (mem::size_of::() as u8) - // } + pub fn offset_vmctx() -> u8 { + 1 * (mem::size_of::() as u8) + } pub fn offset_sig_id() -> u8 { - 1 * (mem::size_of::() as u8) + 2 * (mem::size_of::() as u8) } } @@ -286,10 +299,10 @@ mod vm_offset_tests { offset_of!(ImportedFunc => func).get_byte_offset(), ); - // assert_eq!( - // ImportedFunc::offset_vmctx() as usize, - // offset_of!(ImportedFunc => vmctx).get_byte_offset(), - // ); + assert_eq!( + ImportedFunc::offset_vmctx() as usize, + offset_of!(ImportedFunc => vmctx).get_byte_offset(), + ); } #[test] @@ -337,6 +350,11 @@ mod vm_offset_tests { ImportedMemory::offset_memory() as usize, offset_of!(ImportedMemory => memory).get_byte_offset(), ); + + assert_eq!( + ImportedMemory::offset_vmctx() as usize, + offset_of!(ImportedMemory => vmctx).get_byte_offset(), + ); } #[test] @@ -350,8 +368,8 @@ mod vm_offset_tests { #[test] fn imported_global() { assert_eq!( - ImportedGlobal::offset_data() as usize, - offset_of!(ImportedGlobal => global: LocalGlobal => data).get_byte_offset(), + ImportedGlobal::offset_global() as usize, + offset_of!(ImportedGlobal => global).get_byte_offset(), ); } @@ -362,10 +380,10 @@ mod vm_offset_tests { offset_of!(Anyfunc => func_data: ImportedFunc => func).get_byte_offset(), ); - // assert_eq!( - // Anyfunc::offset_vmctx() as usize, - // offset_of!(Anyfunc => func_data: ImportedFunc => vmctx).get_byte_offset(), - // ); + assert_eq!( + Anyfunc::offset_vmctx() as usize, + offset_of!(Anyfunc => func_data: ImportedFunc => vmctx).get_byte_offset(), + ); assert_eq!( Anyfunc::offset_sig_id() as usize, diff --git a/lib/runtime/src/vmcalls.rs b/lib/runtime/src/vmcalls.rs index c0aaad97b..a41a43137 100644 --- a/lib/runtime/src/vmcalls.rs +++ b/lib/runtime/src/vmcalls.rs @@ -25,7 +25,8 @@ pub unsafe extern "C" fn memory_grow_dynamic( by_pages: u32, ctx: *mut vm::Ctx, ) -> i32 { - if let Some(old) = (*(*ctx).local_backing).memories[memory_index as usize].grow_dynamic(by_pages) + if let Some(old) = + (*(*ctx).local_backing).memories[memory_index as usize].grow_dynamic(by_pages) { // Store the new size back into the vmctx. (*(*ctx).memories.add(memory_index as usize)).size = @@ -34,4 +35,4 @@ pub unsafe extern "C" fn memory_grow_dynamic( } else { -1 } -} \ No newline at end of file +} diff --git a/lib/runtime/tests/spectest.rs b/lib/runtime/tests/spectest.rs index df38ac2d6..4858a3adf 100644 --- a/lib/runtime/tests/spectest.rs +++ b/lib/runtime/tests/spectest.rs @@ -1 +1 @@ -mod spectests; \ No newline at end of file +mod spectests; diff --git a/lib/runtime/tests/spectests/_common.rs b/lib/runtime/tests/spectests/_common.rs index d02acafc7..138aa0728 100644 --- a/lib/runtime/tests/spectests/_common.rs +++ b/lib/runtime/tests/spectests/_common.rs @@ -1,61 +1,29 @@ -use wasmer_runtime::types::{ElementType, FuncSig, Table, Type, Value}; -use wasmer_runtime::{Import, Imports, FuncRef}; -use wasmer_runtime::table::TableBacking; -use std::sync::Arc; +use std::rc::Rc; +use wabt::wat2wasm; +use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::import::Imports; -extern "C" fn print_i32(num: i32) { - println!("{}", num); -} +static IMPORT_MODULE: &str = r#" +(module + (type $t0 (func (param i32))) + (type $t1 (func)) + (func $print_i32 (export "print_i32") (type $t0) (param $lhs i32)) + (func $print (export "print") (type $t1)) + (table $table (export "table") 10 anyfunc) + (memory $memory (export "memory") 1) + (global $global_i32 (export "global_i32") i32 (i32.const 666))) +"#; -extern "C" fn print() {} - -static GLOBAL_I32: i32 = 666; - -pub fn spectest_importobject() -> Imports { - let mut import_object = Imports::new(); - - import_object.add( - "spectest", - "print_i32", - Import::Func( - unsafe { FuncRef::new(print_i32 as _) }, - FuncSig { - params: vec![Type::I32], - returns: vec![], - }, - ), - ); - - import_object.add( - "spectest", - "print", - Import::Func( - unsafe { FuncRef::new(print as _) }, - FuncSig { - params: vec![], - returns: vec![], - }, - ), - ); - - import_object.add( - "spectest".to_string(), - "global_i32".to_string(), - Import::Global(Value::I64(GLOBAL_I32 as _)), - ); - - let table = Table { - ty: ElementType::Anyfunc, - min: 0, - max: Some(30), - }; - import_object.add( - "spectest".to_string(), - "table".to_string(), - Import::Table(Arc::new(TableBacking::new(&table)), table), - ); - - return import_object; +pub fn generate_imports() -> Rc { + let wasm_binary = wat2wasm(IMPORT_MODULE.as_bytes()).expect("WAST not valid or malformed"); + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + let instance = module + .instantiate(Rc::new(Imports::new())) + .expect("WASM can't be instantiated"); + let mut imports = Imports::new(); + imports.register_instance("spectest", instance); + Rc::new(imports) } /// Bit pattern of an f32 value: diff --git a/lib/runtime/tests/spectests/address.rs b/lib/runtime/tests/spectests/address.rs index 7506331b2..7a652c6b3 100644 --- a/lib/runtime/tests/spectests/address.rs +++ b/lib/runtime/tests/spectests/address.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -152,8 +148,11 @@ fn create_module_1() -> Box { (data (;0;) (i32.const 0) \"abcdefghijklmnopqrstuvwxyz\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -757,14 +756,14 @@ fn c74_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c75_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c75_l192_action_invoke"); let result = instance.call("32_good5", &[Value::I32(65508 as i32)]); - + result.map(|_| ()) } #[test] fn c75_l192_assert_trap() { let mut instance = create_module_1(); - let result = c75_l192_action_invoke(&mut*instance); + let result = c75_l192_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -772,14 +771,14 @@ fn c75_l192_assert_trap() { fn c76_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c76_l194_action_invoke"); let result = instance.call("8u_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c76_l194_assert_trap() { let mut instance = create_module_1(); - let result = c76_l194_action_invoke(&mut*instance); + let result = c76_l194_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -787,14 +786,14 @@ fn c76_l194_assert_trap() { fn c77_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c77_l195_action_invoke"); let result = instance.call("8s_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c77_l195_assert_trap() { let mut instance = create_module_1(); - let result = c77_l195_action_invoke(&mut*instance); + let result = c77_l195_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -802,14 +801,14 @@ fn c77_l195_assert_trap() { fn c78_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c78_l196_action_invoke"); let result = instance.call("16u_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c78_l196_assert_trap() { let mut instance = create_module_1(); - let result = c78_l196_action_invoke(&mut*instance); + let result = c78_l196_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -817,14 +816,14 @@ fn c78_l196_assert_trap() { fn c79_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c79_l197_action_invoke"); let result = instance.call("16s_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c79_l197_assert_trap() { let mut instance = create_module_1(); - let result = c79_l197_action_invoke(&mut*instance); + let result = c79_l197_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -832,14 +831,14 @@ fn c79_l197_assert_trap() { fn c80_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c80_l198_action_invoke"); let result = instance.call("32_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c80_l198_assert_trap() { let mut instance = create_module_1(); - let result = c80_l198_action_invoke(&mut*instance); + let result = c80_l198_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -847,14 +846,14 @@ fn c80_l198_assert_trap() { fn c81_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c81_l200_action_invoke"); let result = instance.call("8u_bad", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c81_l200_assert_trap() { let mut instance = create_module_1(); - let result = c81_l200_action_invoke(&mut*instance); + let result = c81_l200_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -862,14 +861,14 @@ fn c81_l200_assert_trap() { fn c82_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c82_l201_action_invoke"); let result = instance.call("8s_bad", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c82_l201_assert_trap() { let mut instance = create_module_1(); - let result = c82_l201_action_invoke(&mut*instance); + let result = c82_l201_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -877,14 +876,14 @@ fn c82_l201_assert_trap() { fn c83_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c83_l202_action_invoke"); let result = instance.call("16u_bad", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c83_l202_assert_trap() { let mut instance = create_module_1(); - let result = c83_l202_action_invoke(&mut*instance); + let result = c83_l202_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -892,14 +891,14 @@ fn c83_l202_assert_trap() { fn c84_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c84_l203_action_invoke"); let result = instance.call("16s_bad", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c84_l203_assert_trap() { let mut instance = create_module_1(); - let result = c84_l203_action_invoke(&mut*instance); + let result = c84_l203_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -907,23 +906,31 @@ fn c84_l203_assert_trap() { fn c85_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c85_l204_action_invoke"); let result = instance.call("32_bad", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c85_l204_assert_trap() { let mut instance = create_module_1(); - let result = c85_l204_action_invoke(&mut*instance); + let result = c85_l204_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 207 #[test] fn c86_l207_assert_malformed() { - let wasm_binary = [40, 109, 101, 109, 111, 114, 121, 32, 49, 41, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 32, 111, 102, 102, 115, 101, 116, 61, 52, 50, 57, 52, 57, 54, 55, 50, 57, 54, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 101, 109, 111, 114, 121, 32, 49, 41, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, + 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 32, 111, 102, 102, 115, 101, 116, 61, 52, + 50, 57, 52, 57, 54, 55, 50, 57, 54, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, + 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 216 @@ -1191,8 +1198,11 @@ fn create_module_2() -> Box { (data (;0;) (i32.const 0) \"abcdefghijklmnopqrstuvwxyz\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -2036,14 +2046,14 @@ fn c191_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c192_l479_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c192_l479_action_invoke"); let result = instance.call("64_good5", &[Value::I32(65504 as i32)]); - + result.map(|_| ()) } #[test] fn c192_l479_assert_trap() { let mut instance = create_module_2(); - let result = c192_l479_action_invoke(&mut*instance); + let result = c192_l479_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2051,14 +2061,14 @@ fn c192_l479_assert_trap() { fn c193_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c193_l481_action_invoke"); let result = instance.call("8u_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c193_l481_assert_trap() { let mut instance = create_module_2(); - let result = c193_l481_action_invoke(&mut*instance); + let result = c193_l481_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2066,14 +2076,14 @@ fn c193_l481_assert_trap() { fn c194_l482_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c194_l482_action_invoke"); let result = instance.call("8s_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c194_l482_assert_trap() { let mut instance = create_module_2(); - let result = c194_l482_action_invoke(&mut*instance); + let result = c194_l482_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2081,14 +2091,14 @@ fn c194_l482_assert_trap() { fn c195_l483_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c195_l483_action_invoke"); let result = instance.call("16u_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c195_l483_assert_trap() { let mut instance = create_module_2(); - let result = c195_l483_action_invoke(&mut*instance); + let result = c195_l483_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2096,14 +2106,14 @@ fn c195_l483_assert_trap() { fn c196_l484_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c196_l484_action_invoke"); let result = instance.call("16s_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c196_l484_assert_trap() { let mut instance = create_module_2(); - let result = c196_l484_action_invoke(&mut*instance); + let result = c196_l484_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2111,14 +2121,14 @@ fn c196_l484_assert_trap() { fn c197_l485_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c197_l485_action_invoke"); let result = instance.call("32u_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c197_l485_assert_trap() { let mut instance = create_module_2(); - let result = c197_l485_action_invoke(&mut*instance); + let result = c197_l485_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2126,14 +2136,14 @@ fn c197_l485_assert_trap() { fn c198_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c198_l486_action_invoke"); let result = instance.call("32s_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c198_l486_assert_trap() { let mut instance = create_module_2(); - let result = c198_l486_action_invoke(&mut*instance); + let result = c198_l486_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2141,14 +2151,14 @@ fn c198_l486_assert_trap() { fn c199_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c199_l487_action_invoke"); let result = instance.call("64_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c199_l487_assert_trap() { let mut instance = create_module_2(); - let result = c199_l487_action_invoke(&mut*instance); + let result = c199_l487_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2156,14 +2166,14 @@ fn c199_l487_assert_trap() { fn c200_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c200_l489_action_invoke"); let result = instance.call("8u_bad", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c200_l489_assert_trap() { let mut instance = create_module_2(); - let result = c200_l489_action_invoke(&mut*instance); + let result = c200_l489_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2171,14 +2181,14 @@ fn c200_l489_assert_trap() { fn c201_l490_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c201_l490_action_invoke"); let result = instance.call("8s_bad", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c201_l490_assert_trap() { let mut instance = create_module_2(); - let result = c201_l490_action_invoke(&mut*instance); + let result = c201_l490_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2186,14 +2196,14 @@ fn c201_l490_assert_trap() { fn c202_l491_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c202_l491_action_invoke"); let result = instance.call("16u_bad", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c202_l491_assert_trap() { let mut instance = create_module_2(); - let result = c202_l491_action_invoke(&mut*instance); + let result = c202_l491_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2201,14 +2211,14 @@ fn c202_l491_assert_trap() { fn c203_l492_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c203_l492_action_invoke"); let result = instance.call("16s_bad", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c203_l492_assert_trap() { let mut instance = create_module_2(); - let result = c203_l492_action_invoke(&mut*instance); + let result = c203_l492_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2216,14 +2226,14 @@ fn c203_l492_assert_trap() { fn c204_l493_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c204_l493_action_invoke"); let result = instance.call("32u_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c204_l493_assert_trap() { let mut instance = create_module_2(); - let result = c204_l493_action_invoke(&mut*instance); + let result = c204_l493_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2231,14 +2241,14 @@ fn c204_l493_assert_trap() { fn c205_l494_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c205_l494_action_invoke"); let result = instance.call("32s_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c205_l494_assert_trap() { let mut instance = create_module_2(); - let result = c205_l494_action_invoke(&mut*instance); + let result = c205_l494_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2246,14 +2256,14 @@ fn c205_l494_assert_trap() { fn c206_l495_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c206_l495_action_invoke"); let result = instance.call("64_bad", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c206_l495_assert_trap() { let mut instance = create_module_2(); - let result = c206_l495_action_invoke(&mut*instance); + let result = c206_l495_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2402,8 +2412,11 @@ fn create_module_3() -> Box { (data (;0;) (i32.const 0) \"\\00\\00\\00\\00\\00\\00\\a0\\7f\\01\\00\\d0\\7f\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -2448,12 +2461,15 @@ fn c212_l527_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c212_l527_action_invoke"); let result = instance.call("32_good5", &[Value::I32(0 as i32)]); let expected = f32::from_bits(2144337921); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2533,14 +2549,14 @@ fn c221_l538_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c222_l539_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c222_l539_action_invoke"); let result = instance.call("32_good5", &[Value::I32(65525 as i32)]); - + result.map(|_| ()) } #[test] fn c222_l539_assert_trap() { let mut instance = create_module_3(); - let result = c222_l539_action_invoke(&mut*instance); + let result = c222_l539_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2548,14 +2564,14 @@ fn c222_l539_assert_trap() { fn c223_l541_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c223_l541_action_invoke"); let result = instance.call("32_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c223_l541_assert_trap() { let mut instance = create_module_3(); - let result = c223_l541_action_invoke(&mut*instance); + let result = c223_l541_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2563,14 +2579,14 @@ fn c223_l541_assert_trap() { fn c224_l542_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c224_l542_action_invoke"); let result = instance.call("32_bad", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c224_l542_assert_trap() { let mut instance = create_module_3(); - let result = c224_l542_action_invoke(&mut*instance); + let result = c224_l542_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2629,8 +2645,11 @@ fn create_module_4() -> Box { (data (;0;) (i32.const 0) \"\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\f4\\7f\\01\\00\\00\\00\\00\\00\\fc\\7f\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { @@ -2675,12 +2694,15 @@ fn c230_l574_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c230_l574_action_invoke"); let result = instance.call("64_good5", &[Value::I32(0 as i32)]); let expected = f64::from_bits(9222246136947933185); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2760,14 +2782,14 @@ fn c239_l585_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c240_l586_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c240_l586_action_invoke"); let result = instance.call("64_good5", &[Value::I32(65511 as i32)]); - + result.map(|_| ()) } #[test] fn c240_l586_assert_trap() { let mut instance = create_module_4(); - let result = c240_l586_action_invoke(&mut*instance); + let result = c240_l586_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2775,14 +2797,14 @@ fn c240_l586_assert_trap() { fn c241_l588_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c241_l588_action_invoke"); let result = instance.call("64_bad", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c241_l588_assert_trap() { let mut instance = create_module_4(); - let result = c241_l588_action_invoke(&mut*instance); + let result = c241_l588_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2790,14 +2812,14 @@ fn c241_l588_assert_trap() { fn c242_l589_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c242_l589_action_invoke"); let result = instance.call("64_bad", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c242_l589_assert_trap() { let mut instance = create_module_4(); - let result = c242_l589_action_invoke(&mut*instance); + let result = c242_l589_action_invoke(&mut *instance); assert!(result.is_err()); } diff --git a/lib/runtime/tests/spectests/align.rs b/lib/runtime/tests/spectests/align.rs index 09cd7268a..4cfc63733 100644 --- a/lib/runtime/tests/spectests/align.rs +++ b/lib/runtime/tests/spectests/align.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -29,8 +25,11 @@ fn create_module_1() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -56,8 +55,11 @@ fn create_module_2() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -83,8 +85,11 @@ fn create_module_3() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -110,8 +115,11 @@ fn create_module_4() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { @@ -137,8 +145,11 @@ fn create_module_5() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_5(instance: &mut Instance) { @@ -164,8 +175,11 @@ fn create_module_6() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_6(instance: &mut Instance) { @@ -191,8 +205,11 @@ fn create_module_7() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_7(instance: &mut Instance) { @@ -218,8 +235,11 @@ fn create_module_8() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_8(instance: &mut Instance) { @@ -245,8 +265,11 @@ fn create_module_9() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_9(instance: &mut Instance) { @@ -272,8 +295,11 @@ fn create_module_10() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_10(instance: &mut Instance) { @@ -299,8 +325,11 @@ fn create_module_11() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_11(instance: &mut Instance) { @@ -326,8 +355,11 @@ fn create_module_12() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_12(instance: &mut Instance) { @@ -353,8 +385,11 @@ fn create_module_13() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_13(instance: &mut Instance) { @@ -380,8 +415,11 @@ fn create_module_14() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_14(instance: &mut Instance) { @@ -407,8 +445,11 @@ fn create_module_15() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_15(instance: &mut Instance) { @@ -434,8 +475,11 @@ fn create_module_16() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_16(instance: &mut Instance) { @@ -461,8 +505,11 @@ fn create_module_17() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_17(instance: &mut Instance) { @@ -488,8 +535,11 @@ fn create_module_18() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_18(instance: &mut Instance) { @@ -515,8 +565,11 @@ fn create_module_19() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_19(instance: &mut Instance) { @@ -542,8 +595,11 @@ fn create_module_20() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_20(instance: &mut Instance) { @@ -569,8 +625,11 @@ fn create_module_21() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_21(instance: &mut Instance) { @@ -596,8 +655,11 @@ fn create_module_22() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_22(instance: &mut Instance) { @@ -623,8 +685,11 @@ fn create_module_23() -> Box { (memory (;0;) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_23(instance: &mut Instance) { @@ -635,375 +700,746 @@ fn start_module_23(instance: &mut Instance) { // Line 28 #[test] fn c23_l28_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 56, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, + 56, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 34 #[test] fn c24_l34_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 56, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, + 56, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 40 #[test] fn c25_l40_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 56, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, + 56, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 46 #[test] fn c26_l46_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 56, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, + 56, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 52 #[test] fn c27_l52_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 49, 54, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, + 49, 54, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 58 #[test] fn c28_l58_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 49, 54, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, + 49, 54, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 64 #[test] fn c29_l64_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 49, 54, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, + 49, 54, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 70 #[test] fn c30_l70_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 49, 54, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, + 49, 54, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 76 #[test] fn c31_l76_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, + 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, + 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 82 #[test] fn c32_l82_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, + 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, + 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 88 #[test] fn c33_l88_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 56, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, + 56, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 94 #[test] fn c34_l94_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 56, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, + 56, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 100 #[test] fn c35_l100_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 56, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, + 56, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 106 #[test] fn c36_l106_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 56, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, + 56, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 112 #[test] fn c37_l112_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 49, 54, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, + 49, 54, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 118 #[test] fn c38_l118_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 49, 54, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, + 49, 54, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 124 #[test] fn c39_l124_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 49, 54, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, + 49, 54, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 130 #[test] fn c40_l130_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 49, 54, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, + 49, 54, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 136 #[test] fn c41_l136_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 51, 50, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, + 51, 50, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 142 #[test] fn c42_l142_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 51, 50, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, + 51, 50, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 148 #[test] fn c43_l148_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 51, 50, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, + 51, 50, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 154 #[test] fn c44_l154_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 51, 50, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, + 51, 50, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 160 #[test] fn c45_l160_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, + 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, + 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 166 #[test] fn c46_l166_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, + 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, + 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 172 #[test] fn c47_l172_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 102, 51, 50, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 102, 51, 50, 46, 108, 111, 97, 100, + 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, + 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 178 #[test] fn c48_l178_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 102, 51, 50, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 102, 51, 50, 46, 108, 111, 97, 100, + 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, + 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 184 #[test] fn c49_l184_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 102, 54, 52, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 102, 54, 52, 46, 108, 111, 97, 100, + 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, + 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 190 #[test] fn c50_l190_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 102, 54, 52, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 102, 54, 52, 46, 108, 111, 97, 100, + 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, + 48, 41, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 197 #[test] fn c51_l197_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 56, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 56, 32, 97, 108, 105, + 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, + 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 203 #[test] fn c52_l203_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 56, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 56, 32, 97, 108, 105, + 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, + 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 209 #[test] fn c53_l209_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 49, 54, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 49, 54, 32, 97, 108, + 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, + 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 215 #[test] fn c54_l215_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 49, 54, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 49, 54, 32, 97, 108, + 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, + 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 221 #[test] fn c55_l221_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, + 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, + 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 227 #[test] fn c56_l227_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, + 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, + 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 233 #[test] fn c57_l233_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 56, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 56, 32, 97, 108, 105, + 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, + 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 239 #[test] fn c58_l239_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 56, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 56, 32, 97, 108, 105, + 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, + 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 245 #[test] fn c59_l245_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 49, 54, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 49, 54, 32, 97, 108, + 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, + 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 251 #[test] fn c60_l251_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 49, 54, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 49, 54, 32, 97, 108, + 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, + 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 257 #[test] fn c61_l257_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 51, 50, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 51, 50, 32, 97, 108, + 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, + 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 263 #[test] fn c62_l263_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 51, 50, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 51, 50, 32, 97, 108, + 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, + 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 269 #[test] fn c63_l269_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, + 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, + 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 275 #[test] fn c64_l275_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, + 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, + 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 281 #[test] fn c65_l281_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, + 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 102, 51, + 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 287 #[test] fn c66_l287_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, + 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 102, 51, + 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 293 #[test] fn c67_l293_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, + 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 102, 51, + 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 299 #[test] fn c68_l299_assert_malformed() { - let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let wasm_binary = [ + 40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, + 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, + 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 102, 51, + 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 306 #[test] fn c69_l306_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 44, 1, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 44, 1, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1011,7 +1447,10 @@ fn c69_l306_assert_invalid() { // Line 310 #[test] fn c70_l310_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 45, 1, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 45, 1, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1019,7 +1458,10 @@ fn c70_l310_assert_invalid() { // Line 314 #[test] fn c71_l314_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 46, 2, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 46, 2, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1027,7 +1469,10 @@ fn c71_l314_assert_invalid() { // Line 318 #[test] fn c72_l318_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 47, 2, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 47, 2, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1035,7 +1480,10 @@ fn c72_l318_assert_invalid() { // Line 322 #[test] fn c73_l322_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 40, 3, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 40, 3, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1043,7 +1491,10 @@ fn c73_l322_assert_invalid() { // Line 326 #[test] fn c74_l326_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 48, 1, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 48, 1, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1051,7 +1502,10 @@ fn c74_l326_assert_invalid() { // Line 330 #[test] fn c75_l330_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 49, 1, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 49, 1, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1059,7 +1513,10 @@ fn c75_l330_assert_invalid() { // Line 334 #[test] fn c76_l334_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 50, 2, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 50, 2, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1067,7 +1524,10 @@ fn c76_l334_assert_invalid() { // Line 338 #[test] fn c77_l338_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 51, 2, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 51, 2, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1075,7 +1535,10 @@ fn c77_l338_assert_invalid() { // Line 342 #[test] fn c78_l342_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 52, 3, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 52, 3, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1083,7 +1546,10 @@ fn c78_l342_assert_invalid() { // Line 346 #[test] fn c79_l346_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 53, 3, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 53, 3, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1091,7 +1557,10 @@ fn c79_l346_assert_invalid() { // Line 350 #[test] fn c80_l350_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 41, 4, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 41, 4, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1099,7 +1568,10 @@ fn c80_l350_assert_invalid() { // Line 354 #[test] fn c81_l354_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 42, 3, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 42, 3, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1107,7 +1579,10 @@ fn c81_l354_assert_invalid() { // Line 358 #[test] fn c82_l358_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 43, 4, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 43, 4, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1115,7 +1590,10 @@ fn c82_l358_assert_invalid() { // Line 363 #[test] fn c83_l363_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 44, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 44, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1123,7 +1601,10 @@ fn c83_l363_assert_invalid() { // Line 367 #[test] fn c84_l367_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 45, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 45, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1131,7 +1612,10 @@ fn c84_l367_assert_invalid() { // Line 371 #[test] fn c85_l371_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 46, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 46, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1139,7 +1623,10 @@ fn c85_l371_assert_invalid() { // Line 375 #[test] fn c86_l375_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 47, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 47, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1147,7 +1634,10 @@ fn c86_l375_assert_invalid() { // Line 379 #[test] fn c87_l379_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 40, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 40, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1155,7 +1645,10 @@ fn c87_l379_assert_invalid() { // Line 383 #[test] fn c88_l383_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 48, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 48, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1163,7 +1656,10 @@ fn c88_l383_assert_invalid() { // Line 387 #[test] fn c89_l387_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 49, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 49, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1171,7 +1667,10 @@ fn c89_l387_assert_invalid() { // Line 391 #[test] fn c90_l391_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 50, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 50, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1179,7 +1678,10 @@ fn c90_l391_assert_invalid() { // Line 395 #[test] fn c91_l395_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 51, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 51, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1187,7 +1689,10 @@ fn c91_l395_assert_invalid() { // Line 399 #[test] fn c92_l399_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 52, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 52, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1195,7 +1700,10 @@ fn c92_l399_assert_invalid() { // Line 403 #[test] fn c93_l403_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 53, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 53, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1203,7 +1711,10 @@ fn c93_l403_assert_invalid() { // Line 407 #[test] fn c94_l407_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 41, 4, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 41, 4, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1211,7 +1722,10 @@ fn c94_l407_assert_invalid() { // Line 411 #[test] fn c95_l411_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 42, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 42, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1219,7 +1733,10 @@ fn c95_l411_assert_invalid() { // Line 415 #[test] fn c96_l415_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 43, 4, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 43, 4, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1227,7 +1744,10 @@ fn c96_l415_assert_invalid() { // Line 420 #[test] fn c97_l420_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 65, 0, 58, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, + 65, 0, 65, 0, 58, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1235,7 +1755,10 @@ fn c97_l420_assert_invalid() { // Line 424 #[test] fn c98_l424_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 65, 0, 59, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, + 65, 0, 65, 0, 59, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1243,7 +1766,10 @@ fn c98_l424_assert_invalid() { // Line 428 #[test] fn c99_l428_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 65, 0, 54, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, + 65, 0, 65, 0, 54, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1251,7 +1777,10 @@ fn c99_l428_assert_invalid() { // Line 432 #[test] fn c100_l432_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 66, 0, 60, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, + 65, 0, 66, 0, 60, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1259,7 +1788,10 @@ fn c100_l432_assert_invalid() { // Line 436 #[test] fn c101_l436_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 66, 0, 61, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, + 65, 0, 66, 0, 61, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1267,7 +1799,10 @@ fn c101_l436_assert_invalid() { // Line 440 #[test] fn c102_l440_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 66, 0, 62, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, + 65, 0, 66, 0, 62, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1275,7 +1810,10 @@ fn c102_l440_assert_invalid() { // Line 444 #[test] fn c103_l444_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 66, 0, 55, 4, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, + 65, 0, 66, 0, 55, 4, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1283,7 +1821,10 @@ fn c103_l444_assert_invalid() { // Line 448 #[test] fn c104_l448_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 14, 1, 12, 0, 65, 0, 67, 0, 0, 0, 0, 56, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 14, 1, 12, + 0, 65, 0, 67, 0, 0, 0, 0, 56, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1291,7 +1832,10 @@ fn c104_l448_assert_invalid() { // Line 452 #[test] fn c105_l452_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 14, 1, 12, 0, 65, 0, 67, 0, 0, 0, 0, 57, 4, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 14, 1, 12, + 0, 65, 0, 67, 0, 0, 0, 0, 57, 4, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1873,8 +2417,11 @@ fn create_module_24() -> Box { (export \"i64_align_switch\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_24(instance: &mut Instance) { @@ -1957,7 +2504,10 @@ fn c115_l811_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 813 fn c116_l813_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c116_l813_action_invoke"); - let result = instance.call("i32_align_switch", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "i32_align_switch", + &[Value::I32(0 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); result.map(|_| ()) } @@ -1965,7 +2515,10 @@ fn c116_l813_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 814 fn c117_l814_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c117_l814_action_invoke"); - let result = instance.call("i32_align_switch", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "i32_align_switch", + &[Value::I32(0 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); result.map(|_| ()) } @@ -1973,7 +2526,10 @@ fn c117_l814_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 815 fn c118_l815_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c118_l815_action_invoke"); - let result = instance.call("i32_align_switch", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "i32_align_switch", + &[Value::I32(1 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); result.map(|_| ()) } @@ -1981,7 +2537,10 @@ fn c118_l815_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 816 fn c119_l816_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c119_l816_action_invoke"); - let result = instance.call("i32_align_switch", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "i32_align_switch", + &[Value::I32(1 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); result.map(|_| ()) } @@ -1989,7 +2548,10 @@ fn c119_l816_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 817 fn c120_l817_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c120_l817_action_invoke"); - let result = instance.call("i32_align_switch", &[Value::I32(2 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "i32_align_switch", + &[Value::I32(2 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); result.map(|_| ()) } @@ -1997,7 +2559,10 @@ fn c120_l817_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 818 fn c121_l818_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c121_l818_action_invoke"); - let result = instance.call("i32_align_switch", &[Value::I32(2 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "i32_align_switch", + &[Value::I32(2 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); result.map(|_| ()) } @@ -2005,7 +2570,10 @@ fn c121_l818_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 819 fn c122_l819_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c122_l819_action_invoke"); - let result = instance.call("i32_align_switch", &[Value::I32(2 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "i32_align_switch", + &[Value::I32(2 as i32), Value::I32(2 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); result.map(|_| ()) } @@ -2013,7 +2581,10 @@ fn c122_l819_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 820 fn c123_l820_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c123_l820_action_invoke"); - let result = instance.call("i32_align_switch", &[Value::I32(3 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "i32_align_switch", + &[Value::I32(3 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); result.map(|_| ()) } @@ -2021,7 +2592,10 @@ fn c123_l820_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 821 fn c124_l821_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c124_l821_action_invoke"); - let result = instance.call("i32_align_switch", &[Value::I32(3 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "i32_align_switch", + &[Value::I32(3 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); result.map(|_| ()) } @@ -2029,7 +2603,10 @@ fn c124_l821_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 822 fn c125_l822_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c125_l822_action_invoke"); - let result = instance.call("i32_align_switch", &[Value::I32(3 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "i32_align_switch", + &[Value::I32(3 as i32), Value::I32(2 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); result.map(|_| ()) } @@ -2037,7 +2614,10 @@ fn c125_l822_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 823 fn c126_l823_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c126_l823_action_invoke"); - let result = instance.call("i32_align_switch", &[Value::I32(4 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "i32_align_switch", + &[Value::I32(4 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); result.map(|_| ()) } @@ -2045,7 +2625,10 @@ fn c126_l823_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 824 fn c127_l824_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c127_l824_action_invoke"); - let result = instance.call("i32_align_switch", &[Value::I32(4 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "i32_align_switch", + &[Value::I32(4 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); result.map(|_| ()) } @@ -2053,7 +2636,10 @@ fn c127_l824_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 825 fn c128_l825_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c128_l825_action_invoke"); - let result = instance.call("i32_align_switch", &[Value::I32(4 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "i32_align_switch", + &[Value::I32(4 as i32), Value::I32(2 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); result.map(|_| ()) } @@ -2061,7 +2647,10 @@ fn c128_l825_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 826 fn c129_l826_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c129_l826_action_invoke"); - let result = instance.call("i32_align_switch", &[Value::I32(4 as i32), Value::I32(4 as i32)]); + let result = instance.call( + "i32_align_switch", + &[Value::I32(4 as i32), Value::I32(4 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); result.map(|_| ()) } @@ -2069,7 +2658,10 @@ fn c129_l826_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 828 fn c130_l828_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c130_l828_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(0 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2077,7 +2669,10 @@ fn c130_l828_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 829 fn c131_l829_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c131_l829_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(0 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2085,7 +2680,10 @@ fn c131_l829_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 830 fn c132_l830_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c132_l830_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(1 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2093,7 +2691,10 @@ fn c132_l830_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 831 fn c133_l831_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c133_l831_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(1 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2101,7 +2702,10 @@ fn c133_l831_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 832 fn c134_l832_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c134_l832_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(2 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(2 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2109,7 +2713,10 @@ fn c134_l832_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 833 fn c135_l833_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c135_l833_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(2 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(2 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2117,7 +2724,10 @@ fn c135_l833_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 834 fn c136_l834_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c136_l834_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(2 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(2 as i32), Value::I32(2 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2125,7 +2735,10 @@ fn c136_l834_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 835 fn c137_l835_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c137_l835_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(3 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(3 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2133,7 +2746,10 @@ fn c137_l835_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 836 fn c138_l836_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c138_l836_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(3 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(3 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2141,7 +2757,10 @@ fn c138_l836_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 837 fn c139_l837_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c139_l837_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(3 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(3 as i32), Value::I32(2 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2149,7 +2768,10 @@ fn c139_l837_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 838 fn c140_l838_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c140_l838_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(4 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(4 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2157,7 +2779,10 @@ fn c140_l838_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 839 fn c141_l839_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c141_l839_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(4 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(4 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2165,7 +2790,10 @@ fn c141_l839_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 840 fn c142_l840_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c142_l840_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(4 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(4 as i32), Value::I32(2 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2173,7 +2801,10 @@ fn c142_l840_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 841 fn c143_l841_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c143_l841_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(4 as i32), Value::I32(4 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(4 as i32), Value::I32(4 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2181,7 +2812,10 @@ fn c143_l841_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 842 fn c144_l842_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c144_l842_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(5 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(5 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2189,7 +2823,10 @@ fn c144_l842_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 843 fn c145_l843_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c145_l843_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(5 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(5 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2197,7 +2834,10 @@ fn c145_l843_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 844 fn c146_l844_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c146_l844_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(5 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(5 as i32), Value::I32(2 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2205,7 +2845,10 @@ fn c146_l844_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 845 fn c147_l845_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c147_l845_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(5 as i32), Value::I32(4 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(5 as i32), Value::I32(4 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2213,7 +2856,10 @@ fn c147_l845_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 846 fn c148_l846_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c148_l846_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(6 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(6 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2221,7 +2867,10 @@ fn c148_l846_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 847 fn c149_l847_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c149_l847_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(6 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(6 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2229,7 +2878,10 @@ fn c149_l847_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 848 fn c150_l848_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c150_l848_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(6 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(6 as i32), Value::I32(2 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2237,7 +2889,10 @@ fn c150_l848_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 849 fn c151_l849_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c151_l849_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(6 as i32), Value::I32(4 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(6 as i32), Value::I32(4 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } @@ -2245,7 +2900,10 @@ fn c151_l849_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 850 fn c152_l850_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c152_l850_action_invoke"); - let result = instance.call("i64_align_switch", &[Value::I32(6 as i32), Value::I32(8 as i32)]); + let result = instance.call( + "i64_align_switch", + &[Value::I32(6 as i32), Value::I32(8 as i32)], + ); assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); result.map(|_| ()) } diff --git a/lib/runtime/tests/spectests/binary.rs b/lib/runtime/tests/spectests/binary.rs index 97e1195b3..e39d6cedd 100644 --- a/lib/runtime/tests/spectests/binary.rs +++ b/lib/runtime/tests/spectests/binary.rs @@ -5,26 +5,25 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { let module_str = "(module) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -44,8 +43,11 @@ fn create_module_2() -> Box { let module_str = "(module) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -65,8 +67,11 @@ fn create_module_3() -> Box { let module_str = "(module) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -86,8 +91,11 @@ fn create_module_4() -> Box { let module_str = "(module) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { @@ -100,7 +108,10 @@ fn start_module_4(instance: &mut Instance) { fn c4_l6_assert_malformed() { let wasm_binary = []; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 7 @@ -108,7 +119,10 @@ fn c4_l6_assert_malformed() { fn c5_l7_assert_malformed() { let wasm_binary = [1]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 8 @@ -116,7 +130,10 @@ fn c5_l7_assert_malformed() { fn c6_l8_assert_malformed() { let wasm_binary = [0, 97, 115]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 9 @@ -124,7 +141,10 @@ fn c6_l8_assert_malformed() { fn c7_l9_assert_malformed() { let wasm_binary = [97, 115, 109, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 10 @@ -132,7 +152,10 @@ fn c7_l9_assert_malformed() { fn c8_l10_assert_malformed() { let wasm_binary = [109, 115, 97, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 11 @@ -140,7 +163,10 @@ fn c8_l10_assert_malformed() { fn c9_l11_assert_malformed() { let wasm_binary = [109, 115, 97, 0, 1, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 12 @@ -148,7 +174,10 @@ fn c9_l11_assert_malformed() { fn c10_l12_assert_malformed() { let wasm_binary = [109, 115, 97, 0, 0, 0, 0, 1]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 13 @@ -156,7 +185,10 @@ fn c10_l12_assert_malformed() { fn c11_l13_assert_malformed() { let wasm_binary = [97, 115, 109, 1, 0, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 14 @@ -164,7 +196,10 @@ fn c11_l13_assert_malformed() { fn c12_l14_assert_malformed() { let wasm_binary = [119, 97, 115, 109, 1, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 15 @@ -172,7 +207,10 @@ fn c12_l14_assert_malformed() { fn c13_l15_assert_malformed() { let wasm_binary = [127, 97, 115, 109, 1, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 16 @@ -180,7 +218,10 @@ fn c13_l15_assert_malformed() { fn c14_l16_assert_malformed() { let wasm_binary = [128, 97, 115, 109, 1, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 17 @@ -188,7 +229,10 @@ fn c14_l16_assert_malformed() { fn c15_l17_assert_malformed() { let wasm_binary = [130, 97, 115, 109, 1, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 18 @@ -196,7 +240,10 @@ fn c15_l17_assert_malformed() { fn c16_l18_assert_malformed() { let wasm_binary = [255, 97, 115, 109, 1, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 21 @@ -204,7 +251,10 @@ fn c16_l18_assert_malformed() { fn c17_l21_assert_malformed() { let wasm_binary = [0, 0, 0, 1, 109, 115, 97, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 24 @@ -212,7 +262,10 @@ fn c17_l21_assert_malformed() { fn c18_l24_assert_malformed() { let wasm_binary = [97, 0, 109, 115, 0, 1, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 25 @@ -220,7 +273,10 @@ fn c18_l24_assert_malformed() { fn c19_l25_assert_malformed() { let wasm_binary = [115, 109, 0, 97, 0, 0, 1, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 28 @@ -228,7 +284,10 @@ fn c19_l25_assert_malformed() { fn c20_l28_assert_malformed() { let wasm_binary = [0, 65, 83, 77, 1, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 31 @@ -236,7 +295,10 @@ fn c20_l28_assert_malformed() { fn c21_l31_assert_malformed() { let wasm_binary = [0, 129, 162, 148, 1, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 34 @@ -244,7 +306,10 @@ fn c21_l31_assert_malformed() { fn c22_l34_assert_malformed() { let wasm_binary = [239, 187, 191, 0, 97, 115, 109, 1, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 36 @@ -252,7 +317,10 @@ fn c22_l34_assert_malformed() { fn c23_l36_assert_malformed() { let wasm_binary = [0, 97, 115, 109]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 37 @@ -260,7 +328,10 @@ fn c23_l36_assert_malformed() { fn c24_l37_assert_malformed() { let wasm_binary = [0, 97, 115, 109, 1]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 38 @@ -268,7 +339,10 @@ fn c24_l37_assert_malformed() { fn c25_l38_assert_malformed() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 39 @@ -276,7 +350,10 @@ fn c25_l38_assert_malformed() { fn c26_l39_assert_malformed() { let wasm_binary = [0, 97, 115, 109, 0, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 40 @@ -284,7 +361,10 @@ fn c26_l39_assert_malformed() { fn c27_l40_assert_malformed() { let wasm_binary = [0, 97, 115, 109, 13, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 41 @@ -292,7 +372,10 @@ fn c27_l40_assert_malformed() { fn c28_l41_assert_malformed() { let wasm_binary = [0, 97, 115, 109, 14, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 42 @@ -300,7 +383,10 @@ fn c28_l41_assert_malformed() { fn c29_l42_assert_malformed() { let wasm_binary = [0, 97, 115, 109, 0, 1, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 43 @@ -308,7 +394,10 @@ fn c29_l42_assert_malformed() { fn c30_l43_assert_malformed() { let wasm_binary = [0, 97, 115, 109, 0, 0, 1, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 44 @@ -316,7 +405,10 @@ fn c30_l43_assert_malformed() { fn c31_l44_assert_malformed() { let wasm_binary = [0, 97, 115, 109, 0, 0, 0, 1]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 47 @@ -332,8 +424,11 @@ fn create_module_5() -> Box { (memory (;0;) 2)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_5(instance: &mut Instance) { @@ -354,8 +449,11 @@ fn create_module_6() -> Box { (memory (;0;) 2)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_6(instance: &mut Instance) { @@ -376,8 +474,11 @@ fn create_module_7() -> Box { (global (;0;) i32 (i32.const 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_7(instance: &mut Instance) { @@ -398,8 +499,11 @@ fn create_module_8() -> Box { (global (;0;) i32 (i32.const -1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_8(instance: &mut Instance) { @@ -420,8 +524,11 @@ fn create_module_9() -> Box { (global (;0;) i32 (i32.const 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_9(instance: &mut Instance) { @@ -442,8 +549,11 @@ fn create_module_10() -> Box { (global (;0;) i32 (i32.const -1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_10(instance: &mut Instance) { @@ -464,8 +574,11 @@ fn create_module_11() -> Box { (global (;0;) i64 (i64.const 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_11(instance: &mut Instance) { @@ -486,8 +599,11 @@ fn create_module_12() -> Box { (global (;0;) i64 (i64.const -1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_12(instance: &mut Instance) { @@ -508,8 +624,11 @@ fn create_module_13() -> Box { (global (;0;) i64 (i64.const 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_13(instance: &mut Instance) { @@ -530,8 +649,11 @@ fn create_module_14() -> Box { (global (;0;) i64 (i64.const -1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_14(instance: &mut Instance) { @@ -553,8 +675,11 @@ fn create_module_15() -> Box { (data (;0;) (i32.const 0) \"\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_15(instance: &mut Instance) { @@ -576,8 +701,11 @@ fn create_module_16() -> Box { (elem (;0;) (i32.const 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_16(instance: &mut Instance) { @@ -588,249 +716,426 @@ fn start_module_16(instance: &mut Instance) { // Line 139 #[test] fn c44_l139_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 8, 1, 0, 130, 128, 128, 128, 128, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 8, 1, 0, 130, 128, 128, 128, 128, 0, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 149 #[test] fn c45_l149_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 1, 127, 0, 65, 128, 128, 128, 128, 128, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 1, 127, 0, 65, 128, 128, 128, 128, 128, 0, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 159 #[test] fn c46_l159_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 1, 127, 0, 65, 255, 255, 255, 255, 255, 127, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 1, 127, 0, 65, 255, 255, 255, 255, 255, 127, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 170 #[test] fn c47_l170_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 16, 1, 126, 0, 66, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 16, 1, 126, 0, 66, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 0, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 180 #[test] fn c48_l180_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 16, 1, 126, 0, 66, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 16, 1, 126, 0, 66, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 127, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 192 #[test] fn c49_l192_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 7, 1, 0, 130, 128, 128, 128, 112]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 7, 1, 0, 130, 128, 128, 128, 112, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 200 #[test] fn c50_l200_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 7, 1, 0, 130, 128, 128, 128, 64]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 7, 1, 0, 130, 128, 128, 128, 64, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 210 #[test] fn c51_l210_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 127, 0, 65, 128, 128, 128, 128, 112, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 127, 0, 65, 128, 128, 128, 128, 112, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 220 #[test] fn c52_l220_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 127, 0, 65, 255, 255, 255, 255, 15, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 127, 0, 65, 255, 255, 255, 255, 15, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 230 #[test] fn c53_l230_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 127, 0, 65, 128, 128, 128, 128, 31, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 127, 0, 65, 128, 128, 128, 128, 31, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 240 #[test] fn c54_l240_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 127, 0, 65, 255, 255, 255, 255, 79, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 127, 0, 65, 255, 255, 255, 255, 79, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 251 #[test] fn c55_l251_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 15, 1, 126, 0, 66, 128, 128, 128, 128, 128, 128, 128, 128, 128, 126, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 15, 1, 126, 0, 66, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 126, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 261 #[test] fn c56_l261_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 15, 1, 126, 0, 66, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 15, 1, 126, 0, 66, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 1, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 271 #[test] fn c57_l271_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 15, 1, 126, 0, 66, 128, 128, 128, 128, 128, 128, 128, 128, 128, 2, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 15, 1, 126, 0, 66, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 2, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 281 #[test] fn c58_l281_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 15, 1, 126, 0, 66, 255, 255, 255, 255, 255, 255, 255, 255, 255, 65, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 15, 1, 126, 0, 66, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 65, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 293 #[test] fn c59_l293_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 9, 1, 7, 0, 65, 0, 17, 0, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 9, 1, + 7, 0, 65, 0, 17, 0, 1, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 312 #[test] fn c60_l312_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 10, 1, 7, 0, 65, 0, 17, 0, 128, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 10, 1, + 7, 0, 65, 0, 17, 0, 128, 0, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 331 #[test] fn c61_l331_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 11, 1, 8, 0, 65, 0, 17, 0, 128, 128, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 11, 1, + 8, 0, 65, 0, 17, 0, 128, 128, 0, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 349 #[test] fn c62_l349_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 12, 1, 9, 0, 65, 0, 17, 0, 128, 128, 128, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 12, 1, + 9, 0, 65, 0, 17, 0, 128, 128, 128, 0, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 367 #[test] fn c63_l367_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 13, 1, 10, 0, 65, 0, 17, 0, 128, 128, 128, 128, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 13, 1, + 10, 0, 65, 0, 17, 0, 128, 128, 128, 128, 0, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 386 #[test] fn c64_l386_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 64, 1, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 65, 0, 64, 1, 26, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 406 #[test] fn c65_l406_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 64, 128, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 65, 0, 64, 128, 0, 26, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 426 #[test] fn c66_l426_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 64, 128, 128, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, + 65, 0, 64, 128, 128, 0, 26, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 445 #[test] fn c67_l445_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 12, 1, 10, 0, 65, 0, 64, 128, 128, 128, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 12, 1, 10, + 0, 65, 0, 64, 128, 128, 128, 0, 26, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 464 #[test] fn c68_l464_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 13, 1, 11, 0, 65, 0, 64, 128, 128, 128, 128, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 13, 1, 11, + 0, 65, 0, 64, 128, 128, 128, 128, 0, 26, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 484 #[test] fn c69_l484_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 7, 1, 5, 0, 63, 1, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 7, 1, 5, 0, + 63, 1, 26, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 503 #[test] fn c70_l503_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 8, 1, 6, 0, 63, 128, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 8, 1, 6, 0, + 63, 128, 0, 26, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 522 #[test] fn c71_l522_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 63, 128, 128, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, + 63, 128, 128, 0, 26, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 540 #[test] fn c72_l540_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 63, 128, 128, 128, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, + 63, 128, 128, 128, 0, 26, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 558 #[test] fn c73_l558_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 63, 128, 128, 128, 128, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, + 63, 128, 128, 128, 128, 0, 26, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 577 #[test] fn c74_l577_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 2, 255, 255, 255, 255, 15, 127, 2, 126, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 2, 255, 255, + 255, 255, 15, 127, 2, 126, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } #[test] diff --git a/lib/runtime/tests/spectests/block.rs b/lib/runtime/tests/spectests/block.rs index b17fa9bba..85a548cc2 100644 --- a/lib/runtime/tests/spectests/block.rs +++ b/lib/runtime/tests/spectests/block.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -536,8 +532,11 @@ fn create_module_1() -> Box { (elem (;0;) (i32.const 0) 19)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -876,7 +875,10 @@ fn c41_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 306 #[test] fn c42_l306_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -884,7 +886,10 @@ fn c42_l306_assert_invalid() { // Line 310 #[test] fn c43_l310_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -892,7 +897,10 @@ fn c43_l310_assert_invalid() { // Line 314 #[test] fn c44_l314_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -900,7 +908,10 @@ fn c44_l314_assert_invalid() { // Line 318 #[test] fn c45_l318_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -908,7 +919,10 @@ fn c45_l318_assert_invalid() { // Line 323 #[test] fn c46_l323_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 64, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 64, 65, 1, + 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -916,7 +930,10 @@ fn c46_l323_assert_invalid() { // Line 329 #[test] fn c47_l329_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 64, 66, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 64, 66, 1, + 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -924,7 +941,10 @@ fn c47_l329_assert_invalid() { // Line 335 #[test] fn c48_l335_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 67, 0, 0, 128, 63, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 67, 0, + 0, 128, 63, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -932,7 +952,10 @@ fn c48_l335_assert_invalid() { // Line 341 #[test] fn c49_l341_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 68, 0, + 0, 0, 0, 0, 0, 240, 63, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -940,7 +963,10 @@ fn c49_l341_assert_invalid() { // Line 348 #[test] fn c50_l348_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 127, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 127, + 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -948,7 +974,10 @@ fn c50_l348_assert_invalid() { // Line 354 #[test] fn c51_l354_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 126, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 126, + 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -956,7 +985,10 @@ fn c51_l354_assert_invalid() { // Line 360 #[test] fn c52_l360_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 125, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 125, + 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -964,7 +996,10 @@ fn c52_l360_assert_invalid() { // Line 366 #[test] fn c53_l366_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 124, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 124, + 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -972,7 +1007,10 @@ fn c53_l366_assert_invalid() { // Line 373 #[test] fn c54_l373_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 127, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 127, 1, + 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -980,7 +1018,10 @@ fn c54_l373_assert_invalid() { // Line 379 #[test] fn c55_l379_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 126, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 126, 1, + 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -988,7 +1029,10 @@ fn c55_l379_assert_invalid() { // Line 385 #[test] fn c56_l385_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 125, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 125, 1, + 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -996,7 +1040,10 @@ fn c56_l385_assert_invalid() { // Line 391 #[test] fn c57_l391_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 124, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 124, 1, + 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1004,7 +1051,10 @@ fn c57_l391_assert_invalid() { // Line 398 #[test] fn c58_l398_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 127, 66, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 127, + 66, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1012,7 +1062,10 @@ fn c58_l398_assert_invalid() { // Line 404 #[test] fn c59_l404_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 127, 67, 0, 0, 0, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 127, + 67, 0, 0, 0, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1020,7 +1073,10 @@ fn c59_l404_assert_invalid() { // Line 410 #[test] fn c60_l410_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, + 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1028,7 +1084,10 @@ fn c60_l410_assert_invalid() { // Line 416 #[test] fn c61_l416_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 126, 65, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 126, + 65, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1036,7 +1095,10 @@ fn c61_l416_assert_invalid() { // Line 422 #[test] fn c62_l422_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 126, 67, 0, 0, 0, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 126, + 67, 0, 0, 0, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1044,7 +1106,10 @@ fn c62_l422_assert_invalid() { // Line 428 #[test] fn c63_l428_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, + 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1052,7 +1117,10 @@ fn c63_l428_assert_invalid() { // Line 434 #[test] fn c64_l434_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 125, 65, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 125, + 65, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1060,7 +1128,10 @@ fn c64_l434_assert_invalid() { // Line 440 #[test] fn c65_l440_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 125, 66, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 125, + 66, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1068,7 +1139,10 @@ fn c65_l440_assert_invalid() { // Line 446 #[test] fn c66_l446_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 125, 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 125, + 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1076,7 +1150,10 @@ fn c66_l446_assert_invalid() { // Line 452 #[test] fn c67_l452_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 124, 65, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 124, + 65, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1084,7 +1161,10 @@ fn c67_l452_assert_invalid() { // Line 458 #[test] fn c68_l458_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 124, 66, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 124, + 66, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1092,7 +1172,10 @@ fn c68_l458_assert_invalid() { // Line 464 #[test] fn c69_l464_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 124, 67, 0, 0, 0, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 124, + 67, 0, 0, 0, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1100,7 +1183,10 @@ fn c69_l464_assert_invalid() { // Line 471 #[test] fn c70_l471_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, + 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1108,7 +1194,10 @@ fn c70_l471_assert_invalid() { // Line 477 #[test] fn c71_l477_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 125, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 125, + 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1116,7 +1205,10 @@ fn c71_l477_assert_invalid() { // Line 483 #[test] fn c72_l483_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 124, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 124, + 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1124,7 +1216,10 @@ fn c72_l483_assert_invalid() { // Line 489 #[test] fn c73_l489_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, + 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1132,7 +1227,10 @@ fn c73_l489_assert_invalid() { // Line 495 #[test] fn c74_l495_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 125, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 125, + 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1140,7 +1238,10 @@ fn c74_l495_assert_invalid() { // Line 501 #[test] fn c75_l501_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 124, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 124, + 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1148,7 +1249,10 @@ fn c75_l501_assert_invalid() { // Line 507 #[test] fn c76_l507_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, + 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1156,7 +1260,10 @@ fn c76_l507_assert_invalid() { // Line 513 #[test] fn c77_l513_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, + 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1164,7 +1271,10 @@ fn c77_l513_assert_invalid() { // Line 519 #[test] fn c78_l519_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 124, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 124, + 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1172,7 +1282,10 @@ fn c78_l519_assert_invalid() { // Line 525 #[test] fn c79_l525_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, + 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1180,7 +1293,10 @@ fn c79_l525_assert_invalid() { // Line 531 #[test] fn c80_l531_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, + 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1188,7 +1304,10 @@ fn c80_l531_assert_invalid() { // Line 537 #[test] fn c81_l537_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 125, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 125, + 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1196,7 +1315,10 @@ fn c81_l537_assert_invalid() { // Line 544 #[test] fn c82_l544_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 127, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 127, + 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1204,7 +1326,10 @@ fn c82_l544_assert_invalid() { // Line 550 #[test] fn c83_l550_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 126, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 126, + 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1212,7 +1337,10 @@ fn c83_l550_assert_invalid() { // Line 556 #[test] fn c84_l556_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 125, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 125, + 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1220,7 +1348,10 @@ fn c84_l556_assert_invalid() { // Line 562 #[test] fn c85_l562_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 124, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 124, + 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1228,7 +1359,10 @@ fn c85_l562_assert_invalid() { // Line 569 #[test] fn c86_l569_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 12, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, + 12, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1236,7 +1370,10 @@ fn c86_l569_assert_invalid() { // Line 575 #[test] fn c87_l575_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, 12, 0, 66, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, + 12, 0, 66, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1244,7 +1381,10 @@ fn c87_l575_assert_invalid() { // Line 581 #[test] fn c88_l581_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 125, 12, 0, 67, 0, 0, 128, 63, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 125, + 12, 0, 67, 0, 0, 128, 63, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1252,7 +1392,10 @@ fn c88_l581_assert_invalid() { // Line 587 #[test] fn c89_l587_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 124, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 124, + 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1260,7 +1403,10 @@ fn c89_l587_assert_invalid() { // Line 594 #[test] fn c90_l594_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 127, 1, 12, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 127, + 1, 12, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1268,7 +1414,10 @@ fn c90_l594_assert_invalid() { // Line 600 #[test] fn c91_l600_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 126, 1, 12, 0, 66, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 126, + 1, 12, 0, 66, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1276,7 +1425,10 @@ fn c91_l600_assert_invalid() { // Line 606 #[test] fn c92_l606_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 125, 1, 12, 0, 67, 0, 0, 128, 63, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 125, + 1, 12, 0, 67, 0, 0, 128, 63, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1284,7 +1436,10 @@ fn c92_l606_assert_invalid() { // Line 612 #[test] fn c93_l612_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 124, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 124, + 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1292,7 +1447,10 @@ fn c93_l612_assert_invalid() { // Line 619 #[test] fn c94_l619_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, 66, 1, 12, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, + 66, 1, 12, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1300,7 +1458,10 @@ fn c94_l619_assert_invalid() { // Line 625 #[test] fn c95_l625_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 67, 0, 0, 128, 63, 12, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, + 67, 0, 0, 128, 63, 12, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1308,7 +1469,10 @@ fn c95_l625_assert_invalid() { // Line 631 #[test] fn c96_l631_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 127, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 127, + 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1316,7 +1480,10 @@ fn c96_l631_assert_invalid() { // Line 637 #[test] fn c97_l637_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 126, 65, 1, 12, 0, 66, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 126, + 65, 1, 12, 0, 66, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1324,7 +1491,10 @@ fn c97_l637_assert_invalid() { // Line 643 #[test] fn c98_l643_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, 67, 0, 0, 128, 63, 12, 0, 66, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, + 67, 0, 0, 128, 63, 12, 0, 66, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1332,7 +1502,10 @@ fn c98_l643_assert_invalid() { // Line 649 #[test] fn c99_l649_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 126, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 66, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 126, + 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 66, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1340,7 +1513,10 @@ fn c99_l649_assert_invalid() { // Line 655 #[test] fn c100_l655_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 125, 65, 1, 12, 0, 67, 0, 0, 128, 63, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 125, + 65, 1, 12, 0, 67, 0, 0, 128, 63, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1348,7 +1524,10 @@ fn c100_l655_assert_invalid() { // Line 661 #[test] fn c101_l661_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 125, 66, 1, 12, 0, 67, 0, 0, 128, 63, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 125, + 66, 1, 12, 0, 67, 0, 0, 128, 63, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1356,7 +1535,10 @@ fn c101_l661_assert_invalid() { // Line 667 #[test] fn c102_l667_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 125, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 67, 0, 0, 128, 63, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 125, + 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 67, 0, 0, 128, 63, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1364,7 +1546,10 @@ fn c102_l667_assert_invalid() { // Line 673 #[test] fn c103_l673_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 126, 65, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 126, + 65, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1372,7 +1557,10 @@ fn c103_l673_assert_invalid() { // Line 679 #[test] fn c104_l679_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 124, 66, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 124, + 66, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1380,7 +1568,10 @@ fn c104_l679_assert_invalid() { // Line 685 #[test] fn c105_l685_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 124, 67, 0, 0, 128, 63, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 124, + 67, 0, 0, 128, 63, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1388,7 +1579,10 @@ fn c105_l685_assert_invalid() { // Line 692 #[test] fn c106_l692_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 1, 12, 0, 65, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, + 1, 12, 0, 65, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1396,7 +1590,10 @@ fn c106_l692_assert_invalid() { // Line 698 #[test] fn c107_l698_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 126, 1, 12, 0, 66, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 126, + 1, 12, 0, 66, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1404,7 +1601,10 @@ fn c107_l698_assert_invalid() { // Line 704 #[test] fn c108_l704_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 125, 1, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 125, + 1, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1412,7 +1612,10 @@ fn c108_l704_assert_invalid() { // Line 710 #[test] fn c109_l710_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 124, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 124, + 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1420,7 +1623,10 @@ fn c109_l710_assert_invalid() { // Line 717 #[test] fn c110_l717_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 127, 66, 1, 12, 0, 65, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 127, + 66, 1, 12, 0, 65, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1428,7 +1634,10 @@ fn c110_l717_assert_invalid() { // Line 723 #[test] fn c111_l723_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 127, 67, 0, 0, 128, 63, 12, 0, 65, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 127, + 67, 0, 0, 128, 63, 12, 0, 65, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1436,7 +1645,10 @@ fn c111_l723_assert_invalid() { // Line 729 #[test] fn c112_l729_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 127, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 65, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 127, + 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 65, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1444,7 +1656,10 @@ fn c112_l729_assert_invalid() { // Line 735 #[test] fn c113_l735_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 126, 65, 1, 12, 0, 66, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 126, + 65, 1, 12, 0, 66, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1452,7 +1667,10 @@ fn c113_l735_assert_invalid() { // Line 741 #[test] fn c114_l741_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 126, 67, 0, 0, 128, 63, 12, 0, 66, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 126, + 67, 0, 0, 128, 63, 12, 0, 66, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1460,7 +1678,10 @@ fn c114_l741_assert_invalid() { // Line 747 #[test] fn c115_l747_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 126, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 66, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 126, + 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 66, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1468,7 +1689,10 @@ fn c115_l747_assert_invalid() { // Line 753 #[test] fn c116_l753_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 125, 65, 1, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 125, + 65, 1, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1476,7 +1700,10 @@ fn c116_l753_assert_invalid() { // Line 759 #[test] fn c117_l759_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 125, 66, 1, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 125, + 66, 1, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1484,7 +1711,10 @@ fn c117_l759_assert_invalid() { // Line 765 #[test] fn c118_l765_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 125, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 125, + 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1492,7 +1722,10 @@ fn c118_l765_assert_invalid() { // Line 771 #[test] fn c119_l771_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 124, 65, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 124, + 65, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1500,7 +1733,10 @@ fn c119_l771_assert_invalid() { // Line 777 #[test] fn c120_l777_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 124, 66, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 124, + 66, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1508,7 +1744,10 @@ fn c120_l777_assert_invalid() { // Line 783 #[test] fn c121_l783_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 124, 67, 0, 0, 128, 63, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 124, + 67, 0, 0, 128, 63, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1516,7 +1755,10 @@ fn c121_l783_assert_invalid() { // Line 790 #[test] fn c122_l790_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 2, 127, 65, 1, 12, 1, 11, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 2, + 127, 65, 1, 12, 1, 11, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1524,7 +1766,10 @@ fn c122_l790_assert_invalid() { // Line 796 #[test] fn c123_l796_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, 2, 126, 66, 1, 12, 1, 11, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, 2, + 126, 66, 1, 12, 1, 11, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1532,7 +1777,10 @@ fn c123_l796_assert_invalid() { // Line 802 #[test] fn c124_l802_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 125, 2, 125, 67, 0, 0, 128, 63, 12, 1, 11, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 125, 2, + 125, 67, 0, 0, 128, 63, 12, 1, 11, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1540,7 +1788,10 @@ fn c124_l802_assert_invalid() { // Line 808 #[test] fn c125_l808_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 124, 2, 124, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 124, 2, + 124, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1548,7 +1799,10 @@ fn c125_l808_assert_invalid() { // Line 815 #[test] fn c126_l815_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 2, 64, 12, 1, 11, 65, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, + 2, 64, 12, 1, 11, 65, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1556,7 +1810,10 @@ fn c126_l815_assert_invalid() { // Line 821 #[test] fn c127_l821_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, 2, 64, 12, 1, 11, 66, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, + 2, 64, 12, 1, 11, 66, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1564,7 +1821,10 @@ fn c127_l821_assert_invalid() { // Line 827 #[test] fn c128_l827_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 125, 2, 64, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 125, + 2, 64, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1572,7 +1832,10 @@ fn c128_l827_assert_invalid() { // Line 833 #[test] fn c129_l833_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 124, 2, 64, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 124, + 2, 64, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1580,7 +1843,10 @@ fn c129_l833_assert_invalid() { // Line 840 #[test] fn c130_l840_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 127, 2, 127, 1, 12, 1, 11, 65, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 127, + 2, 127, 1, 12, 1, 11, 65, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1588,7 +1854,10 @@ fn c130_l840_assert_invalid() { // Line 846 #[test] fn c131_l846_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 126, 2, 126, 1, 12, 1, 11, 66, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 126, + 2, 126, 1, 12, 1, 11, 66, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1596,7 +1865,10 @@ fn c131_l846_assert_invalid() { // Line 852 #[test] fn c132_l852_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 125, 2, 125, 1, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 125, + 2, 125, 1, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1604,7 +1876,10 @@ fn c132_l852_assert_invalid() { // Line 858 #[test] fn c133_l858_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 24, 1, 22, 0, 2, 124, 2, 124, 1, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 24, 1, 22, 0, 2, 124, + 2, 124, 1, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1612,7 +1887,10 @@ fn c133_l858_assert_invalid() { // Line 865 #[test] fn c134_l865_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 127, 2, 127, 66, 1, 12, 1, 11, 65, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 127, + 2, 127, 66, 1, 12, 1, 11, 65, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1620,7 +1898,10 @@ fn c134_l865_assert_invalid() { // Line 873 #[test] fn c135_l873_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 127, 2, 127, 67, 0, 0, 128, 63, 12, 1, 11, 65, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 127, + 2, 127, 67, 0, 0, 128, 63, 12, 1, 11, 65, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1628,7 +1909,10 @@ fn c135_l873_assert_invalid() { // Line 881 #[test] fn c136_l881_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 127, 2, 127, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 65, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 127, + 2, 127, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 65, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1636,7 +1920,10 @@ fn c136_l881_assert_invalid() { // Line 889 #[test] fn c137_l889_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 126, 2, 126, 65, 1, 12, 1, 11, 66, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 126, + 2, 126, 65, 1, 12, 1, 11, 66, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1644,7 +1931,10 @@ fn c137_l889_assert_invalid() { // Line 897 #[test] fn c138_l897_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 126, 2, 126, 67, 0, 0, 128, 63, 12, 1, 11, 66, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 126, + 2, 126, 67, 0, 0, 128, 63, 12, 1, 11, 66, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1652,7 +1942,10 @@ fn c138_l897_assert_invalid() { // Line 905 #[test] fn c139_l905_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 126, 2, 126, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 66, 1, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 126, + 2, 126, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 66, 1, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1660,7 +1953,10 @@ fn c139_l905_assert_invalid() { // Line 913 #[test] fn c140_l913_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 125, 2, 125, 65, 1, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 125, + 2, 125, 65, 1, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1668,7 +1964,10 @@ fn c140_l913_assert_invalid() { // Line 921 #[test] fn c141_l921_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 125, 2, 125, 66, 1, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 125, + 2, 125, 66, 1, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1676,7 +1975,10 @@ fn c141_l921_assert_invalid() { // Line 929 #[test] fn c142_l929_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 28, 1, 26, 0, 2, 125, 2, 125, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 28, 1, 26, 0, 2, 125, + 2, 125, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1684,7 +1986,10 @@ fn c142_l929_assert_invalid() { // Line 937 #[test] fn c143_l937_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 124, 2, 124, 65, 1, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 124, + 2, 124, 65, 1, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1692,7 +1997,10 @@ fn c143_l937_assert_invalid() { // Line 945 #[test] fn c144_l945_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 124, 2, 124, 66, 1, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 124, + 2, 124, 66, 1, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1700,7 +2008,10 @@ fn c144_l945_assert_invalid() { // Line 953 #[test] fn c145_l953_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 28, 1, 26, 0, 2, 124, 2, 124, 67, 0, 0, 128, 63, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 28, 1, 26, 0, 2, 124, + 2, 124, 67, 0, 0, 128, 63, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1708,7 +2019,10 @@ fn c145_l953_assert_invalid() { // Line 962 #[test] fn c146_l962_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 12, 0, 11, 104, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, + 12, 0, 11, 104, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1716,7 +2030,10 @@ fn c146_l962_assert_invalid() { // Line 968 #[test] fn c147_l968_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 12, 0, 11, 122, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, + 12, 0, 11, 122, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1724,7 +2041,10 @@ fn c147_l968_assert_invalid() { // Line 974 #[test] fn c148_l974_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 12, 0, 11, 142, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, + 12, 0, 11, 142, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1732,7 +2052,10 @@ fn c148_l974_assert_invalid() { // Line 980 #[test] fn c149_l980_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 12, 0, 11, 156, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, + 12, 0, 11, 156, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1740,7 +2063,10 @@ fn c149_l980_assert_invalid() { // Line 987 #[test] fn c150_l987_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, 12, 0, 11, 104, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, + 12, 0, 11, 104, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1748,7 +2074,10 @@ fn c150_l987_assert_invalid() { // Line 993 #[test] fn c151_l993_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, 12, 0, 11, 122, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, + 12, 0, 11, 122, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1756,7 +2085,10 @@ fn c151_l993_assert_invalid() { // Line 999 #[test] fn c152_l999_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, 12, 0, 11, 142, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, + 12, 0, 11, 142, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1764,7 +2096,10 @@ fn c152_l999_assert_invalid() { // Line 1005 #[test] fn c153_l1005_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, 12, 0, 11, 156, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, + 12, 0, 11, 156, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1772,7 +2107,10 @@ fn c153_l1005_assert_invalid() { // Line 1012 #[test] fn c154_l1012_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 9, 12, 0, 11, 122, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, + 66, 9, 12, 0, 11, 122, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1780,7 +2118,10 @@ fn c154_l1012_assert_invalid() { // Line 1018 #[test] fn c155_l1018_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 16, 65, 12, 0, 11, 142, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, + 67, 0, 0, 16, 65, 12, 0, 11, 142, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1788,7 +2129,10 @@ fn c155_l1018_assert_invalid() { // Line 1024 #[test] fn c156_l1024_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 64, 68, 0, 0, 0, 0, 0, 0, 34, 64, 12, 0, 11, 156, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 64, + 68, 0, 0, 0, 0, 0, 0, 34, 64, 12, 0, 11, 156, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1796,7 +2140,10 @@ fn c156_l1024_assert_invalid() { // Line 1030 #[test] fn c157_l1030_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 9, 12, 0, 11, 104, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, + 65, 9, 12, 0, 11, 104, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1804,7 +2151,10 @@ fn c157_l1030_assert_invalid() { // Line 1036 #[test] fn c158_l1036_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 16, 65, 12, 0, 11, 142, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, + 67, 0, 0, 16, 65, 12, 0, 11, 142, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1812,7 +2162,10 @@ fn c158_l1036_assert_invalid() { // Line 1042 #[test] fn c159_l1042_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 64, 68, 0, 0, 0, 0, 0, 0, 34, 64, 12, 0, 11, 156, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 64, + 68, 0, 0, 0, 0, 0, 0, 34, 64, 12, 0, 11, 156, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1820,7 +2173,10 @@ fn c159_l1042_assert_invalid() { // Line 1048 #[test] fn c160_l1048_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 9, 12, 0, 11, 104, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, + 65, 9, 12, 0, 11, 104, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1828,7 +2184,10 @@ fn c160_l1048_assert_invalid() { // Line 1054 #[test] fn c161_l1054_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 9, 12, 0, 11, 122, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, + 66, 9, 12, 0, 11, 122, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1836,7 +2195,10 @@ fn c161_l1054_assert_invalid() { // Line 1060 #[test] fn c162_l1060_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 64, 68, 0, 0, 0, 0, 0, 0, 34, 64, 12, 0, 11, 156, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 64, + 68, 0, 0, 0, 0, 0, 0, 34, 64, 12, 0, 11, 156, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1844,7 +2206,10 @@ fn c162_l1060_assert_invalid() { // Line 1066 #[test] fn c163_l1066_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 9, 12, 0, 11, 104, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, + 65, 9, 12, 0, 11, 104, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1852,7 +2217,10 @@ fn c163_l1066_assert_invalid() { // Line 1072 #[test] fn c164_l1072_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 9, 12, 0, 11, 122, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, + 66, 9, 12, 0, 11, 122, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1860,7 +2228,10 @@ fn c164_l1072_assert_invalid() { // Line 1078 #[test] fn c165_l1078_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 16, 65, 12, 0, 11, 142, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, + 67, 0, 0, 16, 65, 12, 0, 11, 142, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1868,17 +2239,28 @@ fn c165_l1078_assert_invalid() { // Line 1085 #[test] fn c166_l1085_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 98, 108, 111, 99, 107, 32, 101, 110, 100, 32, 36, 108, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 98, 108, 111, 99, 107, 32, 101, 110, 100, 32, 36, 108, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 1089 #[test] fn c167_l1089_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 98, 108, 111, 99, 107, 32, 36, 97, 32, 101, 110, 100, 32, 36, 108, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 98, 108, 111, 99, 107, 32, 36, 97, 32, 101, 110, 100, 32, 36, + 108, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } #[test] diff --git a/lib/runtime/tests/spectests/br.rs b/lib/runtime/tests/spectests/br.rs index 161e1a789..b83ed0993 100644 --- a/lib/runtime/tests/spectests/br.rs +++ b/lib/runtime/tests/spectests/br.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -568,8 +564,11 @@ fn create_module_1() -> Box { (elem (;0;) (i32.const 0) 30)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -804,7 +803,10 @@ fn c28_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 371 fn c29_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c29_l371_action_invoke"); - let result = instance.call("as-select-first", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + let result = instance.call( + "as-select-first", + &[Value::I32(0 as i32), Value::I32(6 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); result.map(|_| ()) } @@ -812,7 +814,10 @@ fn c29_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 372 fn c30_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c30_l372_action_invoke"); - let result = instance.call("as-select-first", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + let result = instance.call( + "as-select-first", + &[Value::I32(1 as i32), Value::I32(6 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); result.map(|_| ()) } @@ -820,7 +825,10 @@ fn c30_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 373 fn c31_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c31_l373_action_invoke"); - let result = instance.call("as-select-second", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + let result = instance.call( + "as-select-second", + &[Value::I32(0 as i32), Value::I32(6 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); result.map(|_| ()) } @@ -828,7 +836,10 @@ fn c31_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 374 fn c32_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c32_l374_action_invoke"); - let result = instance.call("as-select-second", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + let result = instance.call( + "as-select-second", + &[Value::I32(1 as i32), Value::I32(6 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); result.map(|_| ()) } @@ -1084,7 +1095,10 @@ fn c63_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 420 #[test] fn c64_l420_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 12, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, + 12, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1092,7 +1106,10 @@ fn c64_l420_assert_invalid() { // Line 427 #[test] fn c65_l427_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 127, 1, 12, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 127, + 1, 12, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1100,7 +1117,10 @@ fn c65_l427_assert_invalid() { // Line 433 #[test] fn c66_l433_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 65, 0, 2, 64, 12, 1, 11, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, + 65, 0, 2, 64, 12, 1, 11, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1108,7 +1128,10 @@ fn c66_l433_assert_invalid() { // Line 439 #[test] fn c67_l439_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, 66, 1, 12, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, + 66, 1, 12, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1116,7 +1139,9 @@ fn c67_l439_assert_invalid() { // Line 446 #[test] fn c68_l446_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 12, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 12, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1124,7 +1149,10 @@ fn c68_l446_assert_invalid() { // Line 450 #[test] fn c69_l450_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 2, 64, 12, 5, 11, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 2, 64, + 12, 5, 11, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1132,7 +1160,10 @@ fn c69_l450_assert_invalid() { // Line 454 #[test] fn c70_l454_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 12, 129, 128, 128, 128, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 12, 129, 128, + 128, 128, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/br_if.rs b/lib/runtime/tests/spectests/br_if.rs index 321a41c38..293cc3a4b 100644 --- a/lib/runtime/tests/spectests/br_if.rs +++ b/lib/runtime/tests/spectests/br_if.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -580,8 +576,11 @@ fn create_module_1() -> Box { (elem (;0;) (i32.const 0) 36)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -1224,7 +1223,10 @@ fn c79_l429_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 432 #[test] fn c80_l432_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, 13, 0, 104, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, + 13, 0, 104, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1232,7 +1234,10 @@ fn c80_l432_assert_invalid() { // Line 436 #[test] fn c81_l436_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, 13, 0, 122, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, + 13, 0, 122, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1240,7 +1245,10 @@ fn c81_l436_assert_invalid() { // Line 440 #[test] fn c82_l440_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, 13, 0, 140, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, + 13, 0, 140, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1248,7 +1256,10 @@ fn c82_l440_assert_invalid() { // Line 444 #[test] fn c83_l444_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, 13, 0, 154, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, + 13, 0, 154, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1256,7 +1267,10 @@ fn c83_l444_assert_invalid() { // Line 449 #[test] fn c84_l449_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 1, 13, 0, 104, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 1, + 13, 0, 104, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1264,7 +1278,10 @@ fn c84_l449_assert_invalid() { // Line 453 #[test] fn c85_l453_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 1, 13, 0, 122, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 1, + 13, 0, 122, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1272,7 +1289,10 @@ fn c85_l453_assert_invalid() { // Line 457 #[test] fn c86_l457_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 128, 63, 13, 0, 140, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, + 0, 128, 63, 13, 0, 140, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1280,7 +1300,10 @@ fn c86_l457_assert_invalid() { // Line 461 #[test] fn c87_l461_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 1, 13, 0, 154, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 1, + 13, 0, 154, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1288,7 +1311,10 @@ fn c87_l461_assert_invalid() { // Line 466 #[test] fn c88_l466_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, 65, 0, 13, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, + 65, 0, 13, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1296,7 +1322,10 @@ fn c88_l466_assert_invalid() { // Line 472 #[test] fn c89_l472_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, 65, 1, 13, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, + 65, 1, 13, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1304,7 +1333,10 @@ fn c89_l472_assert_invalid() { // Line 478 #[test] fn c90_l478_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 0, 65, 0, 13, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 0, + 65, 0, 13, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1312,7 +1344,10 @@ fn c90_l478_assert_invalid() { // Line 484 #[test] fn c91_l484_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 0, 65, 1, 13, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 0, + 65, 1, 13, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1320,7 +1355,10 @@ fn c91_l484_assert_invalid() { // Line 491 #[test] fn c92_l491_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 1, 65, 0, 13, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, + 1, 65, 0, 13, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1328,7 +1366,10 @@ fn c92_l491_assert_invalid() { // Line 497 #[test] fn c93_l497_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 1, 65, 1, 13, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, + 1, 65, 1, 13, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1336,7 +1377,10 @@ fn c93_l497_assert_invalid() { // Line 503 #[test] fn c94_l503_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 66, 1, 65, 0, 13, 0, 26, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, + 66, 1, 65, 0, 13, 0, 26, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1344,7 +1388,10 @@ fn c94_l503_assert_invalid() { // Line 511 #[test] fn c95_l511_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 66, 1, 65, 0, 13, 0, 26, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, + 66, 1, 65, 0, 13, 0, 26, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1352,7 +1399,10 @@ fn c95_l511_assert_invalid() { // Line 520 #[test] fn c96_l520_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 1, 13, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 1, 13, + 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1360,7 +1410,10 @@ fn c96_l520_assert_invalid() { // Line 526 #[test] fn c97_l526_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 66, 0, 13, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 66, 0, + 13, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1368,7 +1421,10 @@ fn c97_l526_assert_invalid() { // Line 532 #[test] fn c98_l532_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 65, 0, 1, 13, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, + 65, 0, 1, 13, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1376,7 +1432,10 @@ fn c98_l532_assert_invalid() { // Line 538 #[test] fn c99_l538_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 65, 0, 2, 64, 65, 1, 13, 1, 11, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, + 65, 0, 2, 64, 65, 1, 13, 1, 11, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1384,7 +1443,10 @@ fn c99_l538_assert_invalid() { // Line 544 #[test] fn c100_l544_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 127, 65, 0, 66, 0, 13, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 127, + 65, 0, 66, 0, 13, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1392,7 +1454,10 @@ fn c100_l544_assert_invalid() { // Line 551 #[test] fn c101_l551_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 8, 1, 6, 0, 65, 1, 13, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 8, 1, 6, 0, 65, 1, 13, 1, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1400,7 +1465,10 @@ fn c101_l551_assert_invalid() { // Line 555 #[test] fn c102_l555_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 64, 2, 64, 65, 1, 13, 5, 11, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 64, 2, 64, + 65, 1, 13, 5, 11, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1408,7 +1476,10 @@ fn c102_l555_assert_invalid() { // Line 559 #[test] fn c103_l559_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 1, 13, 129, 128, 128, 128, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 1, 13, + 129, 128, 128, 128, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/br_table.rs b/lib/runtime/tests/spectests/br_table.rs index 57f7685f9..e9984f0b5 100644 --- a/lib/runtime/tests/spectests/br_table.rs +++ b/lib/runtime/tests/spectests/br_table.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -787,8 +783,11 @@ fn create_module_1() -> Box { (elem (;0;) (i32.const 0) 37)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -1439,7 +1438,10 @@ fn c80_l1341_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1343 fn c81_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c81_l1343_action_invoke"); - let result = instance.call("as-select-first", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + let result = instance.call( + "as-select-first", + &[Value::I32(0 as i32), Value::I32(6 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); result.map(|_| ()) } @@ -1447,7 +1449,10 @@ fn c81_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1344 fn c82_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c82_l1344_action_invoke"); - let result = instance.call("as-select-first", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + let result = instance.call( + "as-select-first", + &[Value::I32(1 as i32), Value::I32(6 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); result.map(|_| ()) } @@ -1455,7 +1460,10 @@ fn c82_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1345 fn c83_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c83_l1345_action_invoke"); - let result = instance.call("as-select-second", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + let result = instance.call( + "as-select-second", + &[Value::I32(0 as i32), Value::I32(6 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); result.map(|_| ()) } @@ -1463,7 +1471,10 @@ fn c83_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1346 fn c84_l1346_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c84_l1346_action_invoke"); - let result = instance.call("as-select-second", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + let result = instance.call( + "as-select-second", + &[Value::I32(1 as i32), Value::I32(6 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); result.map(|_| ()) } @@ -1943,7 +1954,10 @@ fn c143_l1422_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1423 fn c144_l1423_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c144_l1423_action_invoke"); - let result = instance.call("nested-br_table-value-index", &[Value::I32(-1000000 as i32)]); + let result = instance.call( + "nested-br_table-value-index", + &[Value::I32(-1000000 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); result.map(|_| ()) } @@ -1967,7 +1981,10 @@ fn c146_l1426_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1429 #[test] fn c147_l1429_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 64, 65, 1, 14, 0, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 64, + 65, 1, 14, 0, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1975,7 +1992,10 @@ fn c147_l1429_assert_invalid() { // Line 1436 #[test] fn c148_l1436_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 127, 1, 65, 1, 14, 0, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 127, + 1, 65, 1, 14, 0, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1983,7 +2003,10 @@ fn c148_l1436_assert_invalid() { // Line 1442 #[test] fn c149_l1442_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 127, 66, 1, 65, 1, 14, 2, 0, 0, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 127, + 66, 1, 65, 1, 14, 2, 0, 0, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1991,7 +2014,10 @@ fn c149_l1442_assert_invalid() { // Line 1450 #[test] fn c150_l1450_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 64, 2, 125, 67, 0, 0, 0, 0, 65, 0, 14, 1, 0, 1, 11, 26, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 64, 2, + 125, 67, 0, 0, 0, 0, 65, 0, 14, 1, 0, 1, 11, 26, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1999,7 +2025,10 @@ fn c150_l1450_assert_invalid() { // Line 1462 #[test] fn c151_l1462_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 1, 14, 2, 0, 0, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 1, 14, + 2, 0, 0, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -2007,7 +2036,10 @@ fn c151_l1462_assert_invalid() { // Line 1468 #[test] fn c152_l1468_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 0, 14, 0, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 0, + 14, 0, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -2015,7 +2047,10 @@ fn c152_l1468_assert_invalid() { // Line 1474 #[test] fn c153_l1474_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 65, 0, 1, 14, 1, 0, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, + 65, 0, 1, 14, 1, 0, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -2023,7 +2058,10 @@ fn c153_l1474_assert_invalid() { // Line 1480 #[test] fn c154_l1480_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 127, 65, 0, 2, 64, 65, 0, 14, 0, 1, 11, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 127, + 65, 0, 2, 64, 65, 0, 14, 0, 1, 11, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -2031,7 +2069,10 @@ fn c154_l1480_assert_invalid() { // Line 1486 #[test] fn c155_l1486_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 127, 65, 0, 66, 0, 14, 1, 0, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 127, + 65, 0, 66, 0, 14, 1, 0, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -2039,7 +2080,10 @@ fn c155_l1486_assert_invalid() { // Line 1495 #[test] fn c156_l1495_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 1, 14, 1, 2, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 1, + 14, 1, 2, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -2047,7 +2091,10 @@ fn c156_l1495_assert_invalid() { // Line 1501 #[test] fn c157_l1501_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 2, 64, 65, 1, 14, 1, 0, 5, 11, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 2, 64, + 65, 1, 14, 1, 0, 5, 11, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -2055,7 +2102,10 @@ fn c157_l1501_assert_invalid() { // Line 1507 #[test] fn c158_l1507_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 64, 65, 1, 14, 2, 0, 129, 128, 128, 128, 1, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 64, 65, 1, + 14, 2, 0, 129, 128, 128, 128, 1, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -2063,7 +2113,10 @@ fn c158_l1507_assert_invalid() { // Line 1514 #[test] fn c159_l1514_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 1, 14, 1, 1, 2, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 1, + 14, 1, 1, 2, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -2071,7 +2124,10 @@ fn c159_l1514_assert_invalid() { // Line 1520 #[test] fn c160_l1520_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 2, 64, 65, 1, 14, 1, 0, 5, 11, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 2, 64, + 65, 1, 14, 1, 0, 5, 11, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -2079,7 +2135,10 @@ fn c160_l1520_assert_invalid() { // Line 1526 #[test] fn c161_l1526_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 64, 65, 1, 14, 2, 0, 0, 129, 128, 128, 128, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 64, 65, 1, + 14, 2, 0, 0, 129, 128, 128, 128, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/break_drop.rs b/lib/runtime/tests/spectests/break_drop.rs index 858e165ce..0e7ff74c1 100644 --- a/lib/runtime/tests/spectests/break_drop.rs +++ b/lib/runtime/tests/spectests/break_drop.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { @@ -41,8 +37,11 @@ fn create_module_1() -> Box { (export \"br_table\" (func 2))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { diff --git a/lib/runtime/tests/spectests/call.rs b/lib/runtime/tests/spectests/call.rs index aba147282..5c2c156bb 100644 --- a/lib/runtime/tests/spectests/call.rs +++ b/lib/runtime/tests/spectests/call.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -322,8 +318,11 @@ fn create_module_1() -> Box { (elem (;0;) (i32.const 0) 40)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -683,14 +682,14 @@ fn c45_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c46_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c46_l261_action_invoke"); let result = instance.call("as-call_indirect-last", &[]); - + result.map(|_| ()) } #[test] fn c46_l261_assert_trap() { let mut instance = create_module_1(); - let result = c46_l261_action_invoke(&mut*instance); + let result = c46_l261_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -777,7 +776,10 @@ fn c56_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 278 #[test] fn c57_l278_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 10, 10, 2, 5, 0, 16, 1, 69, 11, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 10, 10, 2, 5, 0, 16, 1, 69, + 11, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -785,7 +787,10 @@ fn c57_l278_assert_invalid() { // Line 285 #[test] fn c58_l285_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 0, 0, 96, 0, 1, 126, 3, 3, 2, 0, 1, 10, 12, 2, 5, 0, 16, 1, 69, 11, 4, 0, 66, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 0, 0, 96, 0, 1, 126, 3, 3, 2, 0, 1, 10, 12, 2, 5, + 0, 16, 1, 69, 11, 4, 0, 66, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -793,7 +798,10 @@ fn c58_l285_assert_invalid() { // Line 293 #[test] fn c59_l293_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 0, 0, 96, 1, 127, 0, 3, 3, 2, 0, 1, 10, 9, 2, 4, 0, 16, 1, 11, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 0, 0, 96, 1, 127, 0, 3, 3, 2, 0, 1, 10, 9, 2, 4, + 0, 16, 1, 11, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -801,7 +809,10 @@ fn c59_l293_assert_invalid() { // Line 300 #[test] fn c60_l300_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 124, 127, 0, 3, 3, 2, 0, 1, 10, 9, 2, 4, 0, 16, 1, 11, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 124, 127, 0, 3, 3, 2, 0, 1, 10, 9, + 2, 4, 0, 16, 1, 11, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -809,7 +820,10 @@ fn c60_l300_assert_invalid() { // Line 307 #[test] fn c61_l307_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 10, 11, 2, 6, 0, 65, 1, 16, 1, 11, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 10, 11, 2, 6, 0, 65, 1, 16, + 1, 11, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -817,7 +831,10 @@ fn c61_l307_assert_invalid() { // Line 314 #[test] fn c62_l314_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 10, 20, 2, 15, 0, 68, 0, 0, 0, 0, 0, 0, 0, 64, 65, 1, 16, 1, 11, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 10, 20, 2, 15, 0, 68, 0, 0, + 0, 0, 0, 0, 0, 64, 65, 1, 16, 1, 11, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -825,7 +842,10 @@ fn c62_l314_assert_invalid() { // Line 322 #[test] fn c63_l322_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 127, 127, 0, 3, 3, 2, 0, 1, 10, 12, 2, 7, 0, 1, 65, 1, 16, 1, 11, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 127, 127, 0, 3, 3, 2, 0, 1, 10, 12, + 2, 7, 0, 1, 65, 1, 16, 1, 11, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -833,7 +853,10 @@ fn c63_l322_assert_invalid() { // Line 329 #[test] fn c64_l329_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 127, 127, 0, 3, 3, 2, 0, 1, 10, 12, 2, 7, 0, 65, 1, 1, 16, 1, 11, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 127, 127, 0, 3, 3, 2, 0, 1, 10, 12, + 2, 7, 0, 65, 1, 1, 16, 1, 11, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -841,7 +864,10 @@ fn c64_l329_assert_invalid() { // Line 336 #[test] fn c65_l336_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 127, 124, 0, 3, 3, 2, 0, 1, 10, 20, 2, 15, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 65, 1, 16, 1, 11, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 127, 124, 0, 3, 3, 2, 0, 1, 10, 20, + 2, 15, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 65, 1, 16, 1, 11, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -849,7 +875,10 @@ fn c65_l336_assert_invalid() { // Line 343 #[test] fn c66_l343_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 124, 127, 0, 3, 3, 2, 0, 1, 10, 20, 2, 15, 0, 65, 1, 68, 0, 0, 0, 0, 0, 0, 240, 63, 16, 1, 11, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 124, 127, 0, 3, 3, 2, 0, 1, 10, 20, + 2, 15, 0, 65, 1, 68, 0, 0, 0, 0, 0, 0, 240, 63, 16, 1, 11, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -857,7 +886,9 @@ fn c66_l343_assert_invalid() { // Line 354 #[test] fn c67_l354_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 16, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 16, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -865,7 +896,10 @@ fn c67_l354_assert_invalid() { // Line 358 #[test] fn c68_l358_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 16, 148, 152, 219, 226, 3, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 16, 148, 152, + 219, 226, 3, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/call_indirect.rs b/lib/runtime/tests/spectests/call_indirect.rs index 8fc2c7de9..cf6e1d133 100644 --- a/lib/runtime/tests/spectests/call_indirect.rs +++ b/lib/runtime/tests/spectests/call_indirect.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -518,8 +514,11 @@ fn create_module_1() -> Box { (elem (;0;) (i32.const 0) 0 1 2 3 4 5 6 7 10 8 11 9 35 36 43 44 45 46 47 12 13 14 15 37 38 39 40 41 42)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -1302,95 +1301,226 @@ fn c98_l534_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 539 #[test] fn c99_l539_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, + 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, + 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, + 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, + 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, + 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, + 41, 32, 32, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 551 #[test] fn c100_l551_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, + 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, + 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 112, 97, 114, 97, 109, + 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, + 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, + 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, + 32, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 563 #[test] fn c101_l563_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, + 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, + 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 112, 97, 114, 97, 109, + 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, + 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, + 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, + 41, 32, 32, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 575 #[test] fn c102_l575_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, + 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, + 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 114, 101, 115, 117, + 108, 116, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, + 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, + 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, + 41, 32, 32, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 587 #[test] fn c103_l587_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, + 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, + 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 114, 101, 115, 117, + 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, + 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, + 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, + 41, 32, 32, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 599 #[test] fn c104_l599_assert_malformed() { - let wasm_binary = [40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; + let wasm_binary = [ + 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, + 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, + 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 114, 101, 115, 117, 108, 116, + 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, + 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, + 116, 32, 48, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 609 #[test] fn c105_l609_assert_malformed() { - let wasm_binary = [40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 112, 97, 114, 97, 109, 32, 36, 120, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; + let wasm_binary = [ + 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, + 110, 99, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 112, + 97, 114, 97, 109, 32, 36, 120, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 616 #[test] fn c106_l616_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 41, 41, 40, 116, + 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, + 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, + 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, + 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, + 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 626 #[test] fn c107_l626_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, + 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, + 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, + 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, + 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 636 #[test] fn c108_l636_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, + 102, 117, 110, 99, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, + 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, + 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, + 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 646 #[test] fn c109_l646_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, + 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, + 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, + 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, + 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, + 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, + 116, 32, 48, 41, 32, 32, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 661 #[test] fn c110_l661_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 17, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 17, 0, + 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1398,7 +1528,10 @@ fn c110_l661_assert_invalid() { // Line 669 #[test] fn c111_l669_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 10, 1, 8, 0, 65, 0, 17, 0, 0, 69, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 10, 1, + 8, 0, 65, 0, 17, 0, 0, 69, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1406,7 +1539,10 @@ fn c111_l669_assert_invalid() { // Line 677 #[test] fn c112_l677_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 0, 1, 126, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 10, 1, 8, 0, 65, 0, 17, 0, 0, 69, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 0, 1, 126, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, + 0, 10, 10, 1, 8, 0, 65, 0, 17, 0, 0, 69, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1414,7 +1550,10 @@ fn c112_l677_assert_invalid() { // Line 686 #[test] fn c113_l686_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 9, 1, 7, 0, 65, 0, 17, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, + 0, 10, 9, 1, 7, 0, 65, 0, 17, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1422,7 +1561,10 @@ fn c113_l686_assert_invalid() { // Line 694 #[test] fn c114_l694_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 124, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 9, 1, 7, 0, 65, 0, 17, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 124, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, + 112, 0, 0, 10, 9, 1, 7, 0, 65, 0, 17, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1430,7 +1572,10 @@ fn c114_l694_assert_invalid() { // Line 702 #[test] fn c115_l702_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 11, 1, 9, 0, 65, 1, 65, 0, 17, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 11, 1, + 9, 0, 65, 1, 65, 0, 17, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1438,7 +1583,10 @@ fn c115_l702_assert_invalid() { // Line 710 #[test] fn c116_l710_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 20, 1, 18, 0, 68, 0, 0, 0, 0, 0, 0, 0, 64, 65, 1, 65, 0, 17, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 20, 1, + 18, 0, 68, 0, 0, 0, 0, 0, 0, 0, 64, 65, 1, 65, 0, 17, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1446,7 +1594,10 @@ fn c116_l710_assert_invalid() { // Line 721 #[test] fn c117_l721_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 10, 1, 8, 0, 65, 1, 1, 17, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, + 0, 10, 10, 1, 8, 0, 65, 1, 1, 17, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1454,7 +1605,10 @@ fn c117_l721_assert_invalid() { // Line 729 #[test] fn c118_l729_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 11, 1, 9, 0, 65, 0, 66, 1, 17, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, + 0, 10, 11, 1, 9, 0, 65, 0, 66, 1, 17, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1462,7 +1616,10 @@ fn c118_l729_assert_invalid() { // Line 738 #[test] fn c119_l738_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 127, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 12, 1, 10, 0, 1, 65, 1, 65, 0, 17, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 127, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, + 112, 0, 0, 10, 12, 1, 10, 0, 1, 65, 1, 65, 0, 17, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1470,7 +1627,10 @@ fn c119_l738_assert_invalid() { // Line 748 #[test] fn c120_l748_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 127, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 12, 1, 10, 0, 65, 1, 1, 65, 0, 17, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 127, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, + 112, 0, 0, 10, 12, 1, 10, 0, 65, 1, 1, 65, 0, 17, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1478,7 +1638,10 @@ fn c120_l748_assert_invalid() { // Line 758 #[test] fn c121_l758_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 127, 124, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 20, 1, 18, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 65, 1, 65, 0, 17, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 127, 124, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, + 112, 0, 0, 10, 20, 1, 18, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 65, 1, 65, 0, 17, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1486,7 +1649,10 @@ fn c121_l758_assert_invalid() { // Line 768 #[test] fn c122_l768_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 124, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 20, 1, 18, 0, 65, 1, 68, 0, 0, 0, 0, 0, 0, 240, 63, 65, 0, 17, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 124, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, + 112, 0, 0, 10, 20, 1, 18, 0, 65, 1, 68, 0, 0, 0, 0, 0, 0, 240, 63, 65, 0, 17, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1494,7 +1660,10 @@ fn c122_l768_assert_invalid() { // Line 782 #[test] fn c123_l782_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 9, 1, 7, 0, 65, 0, 17, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 9, 1, + 7, 0, 65, 0, 17, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1502,7 +1671,10 @@ fn c123_l782_assert_invalid() { // Line 789 #[test] fn c124_l789_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 13, 1, 11, 0, 65, 0, 17, 148, 152, 219, 226, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 13, 1, + 11, 0, 65, 0, 17, 148, 152, 219, 226, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1510,7 +1682,9 @@ fn c124_l789_assert_invalid() { // Line 800 #[test] fn c125_l800_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 5, 1, 112, 1, 2, 2, 9, 8, 1, 0, 65, 0, 11, 2, 0, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 5, 1, 112, 1, 2, 2, 9, 8, 1, 0, 65, 0, 11, 2, 0, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/comments.rs b/lib/runtime/tests/spectests/comments.rs index 1c1862449..bd280977e 100644 --- a/lib/runtime/tests/spectests/comments.rs +++ b/lib/runtime/tests/spectests/comments.rs @@ -5,26 +5,25 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 10 fn create_module_1() -> Box { let module_str = "(module) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -44,8 +43,11 @@ fn create_module_2() -> Box { let module_str = "(module) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -65,8 +67,11 @@ fn create_module_3() -> Box { let module_str = "(module) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -86,8 +91,11 @@ fn create_module_4() -> Box { let module_str = "(module) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { diff --git a/lib/runtime/tests/spectests/const_.rs b/lib/runtime/tests/spectests/const_.rs index 5a2e0e7aa..610b6a020 100644 --- a/lib/runtime/tests/spectests/const_.rs +++ b/lib/runtime/tests/spectests/const_.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 5 fn create_module_1() -> Box { @@ -27,8 +23,11 @@ fn create_module_1() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -52,8 +51,11 @@ fn create_module_2() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -64,17 +66,29 @@ fn start_module_2(instance: &mut Instance) { // Line 8 #[test] fn c2_l8_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 48, 48, 48, 48, 48, 48, 48, 48, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, + 48, 48, 48, 48, 48, 48, 48, 48, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 12 #[test] fn c3_l12_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, 56, 48, 48, 48, 48, 48, 48, 49, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, + 56, 48, 48, 48, 48, 48, 48, 49, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 16 @@ -93,8 +107,11 @@ fn create_module_3() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -118,8 +135,11 @@ fn create_module_4() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { @@ -130,17 +150,29 @@ fn start_module_4(instance: &mut Instance) { // Line 19 #[test] fn c6_l19_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 52, 50, 57, 52, 57, 54, 55, 50, 57, 54, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 52, 50, 57, 52, + 57, 54, 55, 50, 57, 54, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 23 #[test] fn c7_l23_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 50, 49, 52, 55, 52, 56, 51, 54, 52, 57, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 50, 49, 52, + 55, 52, 56, 51, 54, 52, 57, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 27 @@ -159,8 +191,11 @@ fn create_module_5() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_5(instance: &mut Instance) { @@ -184,8 +219,11 @@ fn create_module_6() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_6(instance: &mut Instance) { @@ -196,17 +234,31 @@ fn start_module_6(instance: &mut Instance) { // Line 30 #[test] fn c10_l30_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, + 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 41, 32, 100, 114, 111, 112, + 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 34 #[test] fn c11_l34_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, 56, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 49, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, + 56, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 49, 41, 32, 100, 114, 111, 112, + 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 38 @@ -225,8 +277,11 @@ fn create_module_7() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_7(instance: &mut Instance) { @@ -250,8 +305,11 @@ fn create_module_8() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_8(instance: &mut Instance) { @@ -262,17 +320,31 @@ fn start_module_8(instance: &mut Instance) { // Line 41 #[test] fn c14_l41_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 56, 52, 52, 54, 55, 52, 52, 48, 55, 51, 55, 48, 57, 53, 53, 49, 54, 49, 54, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 56, 52, 52, + 54, 55, 52, 52, 48, 55, 51, 55, 48, 57, 53, 53, 49, 54, 49, 54, 41, 32, 100, 114, 111, 112, + 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 45 #[test] fn c15_l45_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 57, 50, 50, 51, 51, 55, 50, 48, 51, 54, 56, 53, 52, 55, 55, 53, 56, 48, 57, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 57, 50, 50, + 51, 51, 55, 50, 48, 51, 54, 56, 53, 52, 55, 55, 53, 56, 48, 57, 41, 32, 100, 114, 111, 112, + 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 49 @@ -291,8 +363,11 @@ fn create_module_9() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_9(instance: &mut Instance) { @@ -316,8 +391,11 @@ fn create_module_10() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_10(instance: &mut Instance) { @@ -341,8 +419,11 @@ fn create_module_11() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_11(instance: &mut Instance) { @@ -366,8 +447,11 @@ fn create_module_12() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_12(instance: &mut Instance) { @@ -391,8 +475,11 @@ fn create_module_13() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_13(instance: &mut Instance) { @@ -416,8 +503,11 @@ fn create_module_14() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_14(instance: &mut Instance) { @@ -428,33 +518,57 @@ fn start_module_14(instance: &mut Instance) { // Line 56 #[test] fn c22_l56_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 112, 49, 50, 56, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, + 112, 49, 50, 56, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 60 #[test] fn c23_l60_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, 49, 112, 49, 50, 56, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, + 49, 112, 49, 50, 56, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 64 #[test] fn c24_l64_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 102, 102, 102, 102, 102, 102, 112, 49, 50, 55, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, + 46, 102, 102, 102, 102, 102, 102, 112, 49, 50, 55, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 68 #[test] fn c25_l68_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, 49, 46, 102, 102, 102, 102, 102, 102, 112, 49, 50, 55, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, + 49, 46, 102, 102, 102, 102, 102, 102, 112, 49, 50, 55, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 72 @@ -473,8 +587,11 @@ fn create_module_15() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_15(instance: &mut Instance) { @@ -498,8 +615,11 @@ fn create_module_16() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_16(instance: &mut Instance) { @@ -510,17 +630,29 @@ fn start_module_16(instance: &mut Instance) { // Line 75 #[test] fn c28_l75_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 101, 51, 57, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 101, 51, + 57, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 79 #[test] fn c29_l79_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 49, 101, 51, 57, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 49, 101, + 51, 57, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 83 @@ -539,8 +671,11 @@ fn create_module_17() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_17(instance: &mut Instance) { @@ -564,8 +699,11 @@ fn create_module_18() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_18(instance: &mut Instance) { @@ -576,17 +714,31 @@ fn start_module_18(instance: &mut Instance) { // Line 86 #[test] fn c32_l86_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 51, 52, 48, 50, 56, 50, 51, 53, 54, 55, 55, 57, 55, 51, 51, 54, 54, 49, 54, 51, 55, 53, 51, 57, 51, 57, 53, 52, 53, 56, 49, 52, 50, 53, 54, 56, 52, 52, 56, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 51, 52, 48, 50, + 56, 50, 51, 53, 54, 55, 55, 57, 55, 51, 51, 54, 54, 49, 54, 51, 55, 53, 51, 57, 51, 57, 53, + 52, 53, 56, 49, 52, 50, 53, 54, 56, 52, 52, 56, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 90 #[test] fn c33_l90_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 51, 52, 48, 50, 56, 50, 51, 53, 54, 55, 55, 57, 55, 51, 51, 54, 54, 49, 54, 51, 55, 53, 51, 57, 51, 57, 53, 52, 53, 56, 49, 52, 50, 53, 54, 56, 52, 52, 56, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 51, 52, 48, + 50, 56, 50, 51, 53, 54, 55, 55, 57, 55, 51, 51, 54, 54, 49, 54, 51, 55, 53, 51, 57, 51, 57, + 53, 52, 53, 56, 49, 52, 50, 53, 54, 56, 52, 52, 56, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 94 @@ -605,8 +757,11 @@ fn create_module_19() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_19(instance: &mut Instance) { @@ -630,8 +785,11 @@ fn create_module_20() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_20(instance: &mut Instance) { @@ -655,8 +813,11 @@ fn create_module_21() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_21(instance: &mut Instance) { @@ -680,8 +841,11 @@ fn create_module_22() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_22(instance: &mut Instance) { @@ -705,8 +869,11 @@ fn create_module_23() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_23(instance: &mut Instance) { @@ -730,8 +897,11 @@ fn create_module_24() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_24(instance: &mut Instance) { @@ -742,33 +912,59 @@ fn start_module_24(instance: &mut Instance) { // Line 101 #[test] fn c40_l101_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 112, 49, 48, 50, 52, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, + 112, 49, 48, 50, 52, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 105 #[test] fn c41_l105_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, 49, 112, 49, 48, 50, 52, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, + 49, 112, 49, 48, 50, 52, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 109 #[test] fn c42_l109_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 56, 112, 49, 48, 50, 51, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, + 46, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 56, 112, 49, 48, 50, + 51, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 113 #[test] fn c43_l113_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, 49, 46, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 56, 112, 49, 48, 50, 51, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, + 49, 46, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 56, 112, 49, 48, + 50, 51, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 117 @@ -787,8 +983,11 @@ fn create_module_25() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_25(instance: &mut Instance) { @@ -812,8 +1011,11 @@ fn create_module_26() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_26(instance: &mut Instance) { @@ -824,17 +1026,29 @@ fn start_module_26(instance: &mut Instance) { // Line 120 #[test] fn c46_l120_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 101, 51, 48, 57, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 101, 51, + 48, 57, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 124 #[test] fn c47_l124_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 49, 101, 51, 48, 57, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 49, 101, + 51, 48, 57, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 128 @@ -853,8 +1067,11 @@ fn create_module_27() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_27(instance: &mut Instance) { @@ -878,8 +1095,11 @@ fn create_module_28() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_28(instance: &mut Instance) { @@ -890,17 +1110,55 @@ fn start_module_28(instance: &mut Instance) { // Line 131 #[test] fn c50_l131_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 50, 54, 57, 54, 53, 51, 57, 55, 48, 50, 50, 57, 51, 52, 55, 51, 53, 54, 50, 50, 49, 55, 57, 49, 49, 51, 53, 53, 57, 55, 53, 53, 54, 53, 51, 53, 49, 57, 55, 49, 48, 53, 56, 53, 49, 50, 56, 56, 55, 54, 55, 52, 57, 52, 56, 57, 56, 51, 55, 54, 50, 49, 53, 50, 48, 52, 55, 51, 53, 56, 57, 49, 49, 55, 48, 48, 52, 50, 56, 48, 56, 49, 52, 48, 56, 56, 52, 51, 51, 55, 57, 52, 57, 49, 53, 48, 51, 49, 55, 50, 53, 55, 51, 49, 48, 54, 56, 56, 52, 51, 48, 50, 55, 49, 53, 55, 51, 54, 57, 54, 51, 53, 49, 52, 56, 49, 57, 57, 48, 51, 51, 52, 49, 57, 54, 50, 55, 52, 49, 53, 50, 55, 48, 49, 51, 50, 48, 48, 53, 53, 51, 48, 54, 50, 55, 53, 52, 55, 57, 48, 55, 52, 56, 54, 53, 56, 54, 52, 56, 50, 54, 57, 50, 51, 49, 49, 52, 51, 54, 56, 50, 51, 53, 49, 51, 53, 53, 56, 51, 57, 57, 51, 52, 49, 54, 49, 49, 51, 56, 48, 50, 55, 54, 50, 54, 56, 50, 55, 48, 48, 57, 49, 51, 52, 53, 54, 56, 55, 52, 56, 53, 53, 51, 53, 52, 56, 51, 52, 52, 50, 50, 50, 52, 56, 55, 49, 50, 56, 51, 56, 57, 57, 56, 49, 56, 53, 48, 50, 50, 52, 49, 50, 49, 57, 54, 55, 51, 57, 51, 48, 54, 50, 49, 55, 48, 56, 52, 55, 53, 51, 49, 48, 55, 50, 54, 53, 55, 55, 49, 51, 55, 56, 57, 52, 57, 56, 50, 49, 56, 55, 53, 54, 48, 54, 48, 51, 57, 50, 55, 54, 49, 56, 55, 50, 56, 55, 53, 53, 50, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 50, 54, 57, 54, + 53, 51, 57, 55, 48, 50, 50, 57, 51, 52, 55, 51, 53, 54, 50, 50, 49, 55, 57, 49, 49, 51, 53, + 53, 57, 55, 53, 53, 54, 53, 51, 53, 49, 57, 55, 49, 48, 53, 56, 53, 49, 50, 56, 56, 55, 54, + 55, 52, 57, 52, 56, 57, 56, 51, 55, 54, 50, 49, 53, 50, 48, 52, 55, 51, 53, 56, 57, 49, 49, + 55, 48, 48, 52, 50, 56, 48, 56, 49, 52, 48, 56, 56, 52, 51, 51, 55, 57, 52, 57, 49, 53, 48, + 51, 49, 55, 50, 53, 55, 51, 49, 48, 54, 56, 56, 52, 51, 48, 50, 55, 49, 53, 55, 51, 54, 57, + 54, 51, 53, 49, 52, 56, 49, 57, 57, 48, 51, 51, 52, 49, 57, 54, 50, 55, 52, 49, 53, 50, 55, + 48, 49, 51, 50, 48, 48, 53, 53, 51, 48, 54, 50, 55, 53, 52, 55, 57, 48, 55, 52, 56, 54, 53, + 56, 54, 52, 56, 50, 54, 57, 50, 51, 49, 49, 52, 51, 54, 56, 50, 51, 53, 49, 51, 53, 53, 56, + 51, 57, 57, 51, 52, 49, 54, 49, 49, 51, 56, 48, 50, 55, 54, 50, 54, 56, 50, 55, 48, 48, 57, + 49, 51, 52, 53, 54, 56, 55, 52, 56, 53, 53, 51, 53, 52, 56, 51, 52, 52, 50, 50, 50, 52, 56, + 55, 49, 50, 56, 51, 56, 57, 57, 56, 49, 56, 53, 48, 50, 50, 52, 49, 50, 49, 57, 54, 55, 51, + 57, 51, 48, 54, 50, 49, 55, 48, 56, 52, 55, 53, 51, 49, 48, 55, 50, 54, 53, 55, 55, 49, 51, + 55, 56, 57, 52, 57, 56, 50, 49, 56, 55, 53, 54, 48, 54, 48, 51, 57, 50, 55, 54, 49, 56, 55, + 50, 56, 55, 53, 53, 50, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 135 #[test] fn c51_l135_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 50, 54, 57, 54, 53, 51, 57, 55, 48, 50, 50, 57, 51, 52, 55, 51, 53, 54, 50, 50, 49, 55, 57, 49, 49, 51, 53, 53, 57, 55, 53, 53, 54, 53, 51, 53, 49, 57, 55, 49, 48, 53, 56, 53, 49, 50, 56, 56, 55, 54, 55, 52, 57, 52, 56, 57, 56, 51, 55, 54, 50, 49, 53, 50, 48, 52, 55, 51, 53, 56, 57, 49, 49, 55, 48, 48, 52, 50, 56, 48, 56, 49, 52, 48, 56, 56, 52, 51, 51, 55, 57, 52, 57, 49, 53, 48, 51, 49, 55, 50, 53, 55, 51, 49, 48, 54, 56, 56, 52, 51, 48, 50, 55, 49, 53, 55, 51, 54, 57, 54, 51, 53, 49, 52, 56, 49, 57, 57, 48, 51, 51, 52, 49, 57, 54, 50, 55, 52, 49, 53, 50, 55, 48, 49, 51, 50, 48, 48, 53, 53, 51, 48, 54, 50, 55, 53, 52, 55, 57, 48, 55, 52, 56, 54, 53, 56, 54, 52, 56, 50, 54, 57, 50, 51, 49, 49, 52, 51, 54, 56, 50, 51, 53, 49, 51, 53, 53, 56, 51, 57, 57, 51, 52, 49, 54, 49, 49, 51, 56, 48, 50, 55, 54, 50, 54, 56, 50, 55, 48, 48, 57, 49, 51, 52, 53, 54, 56, 55, 52, 56, 53, 53, 51, 53, 52, 56, 51, 52, 52, 50, 50, 50, 52, 56, 55, 49, 50, 56, 51, 56, 57, 57, 56, 49, 56, 53, 48, 50, 50, 52, 49, 50, 49, 57, 54, 55, 51, 57, 51, 48, 54, 50, 49, 55, 48, 56, 52, 55, 53, 51, 49, 48, 55, 50, 54, 53, 55, 55, 49, 51, 55, 56, 57, 52, 57, 56, 50, 49, 56, 55, 53, 54, 48, 54, 48, 51, 57, 50, 55, 54, 49, 56, 55, 50, 56, 55, 53, 53, 50, 41, 32, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 50, 54, 57, + 54, 53, 51, 57, 55, 48, 50, 50, 57, 51, 52, 55, 51, 53, 54, 50, 50, 49, 55, 57, 49, 49, 51, + 53, 53, 57, 55, 53, 53, 54, 53, 51, 53, 49, 57, 55, 49, 48, 53, 56, 53, 49, 50, 56, 56, 55, + 54, 55, 52, 57, 52, 56, 57, 56, 51, 55, 54, 50, 49, 53, 50, 48, 52, 55, 51, 53, 56, 57, 49, + 49, 55, 48, 48, 52, 50, 56, 48, 56, 49, 52, 48, 56, 56, 52, 51, 51, 55, 57, 52, 57, 49, 53, + 48, 51, 49, 55, 50, 53, 55, 51, 49, 48, 54, 56, 56, 52, 51, 48, 50, 55, 49, 53, 55, 51, 54, + 57, 54, 51, 53, 49, 52, 56, 49, 57, 57, 48, 51, 51, 52, 49, 57, 54, 50, 55, 52, 49, 53, 50, + 55, 48, 49, 51, 50, 48, 48, 53, 53, 51, 48, 54, 50, 55, 53, 52, 55, 57, 48, 55, 52, 56, 54, + 53, 56, 54, 52, 56, 50, 54, 57, 50, 51, 49, 49, 52, 51, 54, 56, 50, 51, 53, 49, 51, 53, 53, + 56, 51, 57, 57, 51, 52, 49, 54, 49, 49, 51, 56, 48, 50, 55, 54, 50, 54, 56, 50, 55, 48, 48, + 57, 49, 51, 52, 53, 54, 56, 55, 52, 56, 53, 53, 51, 53, 52, 56, 51, 52, 52, 50, 50, 50, 52, + 56, 55, 49, 50, 56, 51, 56, 57, 57, 56, 49, 56, 53, 48, 50, 50, 52, 49, 50, 49, 57, 54, 55, + 51, 57, 51, 48, 54, 50, 49, 55, 48, 56, 52, 55, 53, 51, 49, 48, 55, 50, 54, 53, 55, 55, 49, + 51, 55, 56, 57, 52, 57, 56, 50, 49, 56, 55, 53, 54, 48, 54, 48, 51, 57, 50, 55, 54, 49, 56, + 55, 50, 56, 55, 53, 53, 50, 41, 32, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } #[test] diff --git a/lib/runtime/tests/spectests/conversions.rs b/lib/runtime/tests/spectests/conversions.rs index 2afdacf15..54e565378 100644 --- a/lib/runtime/tests/spectests/conversions.rs +++ b/lib/runtime/tests/spectests/conversions.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { @@ -135,8 +131,11 @@ fn create_module_1() -> Box { (export \"i64.reinterpret_f64\" (func 24))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -355,7 +354,12 @@ fn c26_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 58 fn c27_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c27_l58_action_invoke"); - let result = instance.call("i32.trunc_s_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "i32.trunc_s_f32", + &[Value::F32( + (0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -363,7 +367,12 @@ fn c27_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 59 fn c28_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c28_l59_action_invoke"); - let result = instance.call("i32.trunc_s_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "i32.trunc_s_f32", + &[Value::F32( + (-0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -452,14 +461,14 @@ fn c38_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c39_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c39_l70_action_invoke"); let result = instance.call("i32.trunc_s_f32", &[Value::F32((2147483600.0f32))]); - + result.map(|_| ()) } #[test] fn c39_l70_assert_trap() { let mut instance = create_module_1(); - let result = c39_l70_action_invoke(&mut*instance); + let result = c39_l70_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -467,14 +476,14 @@ fn c39_l70_assert_trap() { fn c40_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c40_l71_action_invoke"); let result = instance.call("i32.trunc_s_f32", &[Value::F32((-2147484000.0f32))]); - + result.map(|_| ()) } #[test] fn c40_l71_assert_trap() { let mut instance = create_module_1(); - let result = c40_l71_action_invoke(&mut*instance); + let result = c40_l71_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -482,14 +491,14 @@ fn c40_l71_assert_trap() { fn c41_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c41_l72_action_invoke"); let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::INFINITY)]); - + result.map(|_| ()) } #[test] fn c41_l72_assert_trap() { let mut instance = create_module_1(); - let result = c41_l72_action_invoke(&mut*instance); + let result = c41_l72_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -497,14 +506,14 @@ fn c41_l72_assert_trap() { fn c42_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c42_l73_action_invoke"); let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::NEG_INFINITY)]); - + result.map(|_| ()) } #[test] fn c42_l73_assert_trap() { let mut instance = create_module_1(); - let result = c42_l73_action_invoke(&mut*instance); + let result = c42_l73_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -512,14 +521,14 @@ fn c42_l73_assert_trap() { fn c43_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c43_l74_action_invoke"); let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::from_bits(2143289344))]); - + result.map(|_| ()) } #[test] fn c43_l74_assert_trap() { let mut instance = create_module_1(); - let result = c43_l74_action_invoke(&mut*instance); + let result = c43_l74_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -527,14 +536,14 @@ fn c43_l74_assert_trap() { fn c44_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c44_l75_action_invoke"); let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::from_bits(2141192192))]); - + result.map(|_| ()) } #[test] fn c44_l75_assert_trap() { let mut instance = create_module_1(); - let result = c44_l75_action_invoke(&mut*instance); + let result = c44_l75_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -542,14 +551,14 @@ fn c44_l75_assert_trap() { fn c45_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c45_l76_action_invoke"); let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::from_bits(4290772992))]); - + result.map(|_| ()) } #[test] fn c45_l76_assert_trap() { let mut instance = create_module_1(); - let result = c45_l76_action_invoke(&mut*instance); + let result = c45_l76_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -557,14 +566,14 @@ fn c45_l76_assert_trap() { fn c46_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c46_l77_action_invoke"); let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::from_bits(4288675840))]); - + result.map(|_| ()) } #[test] fn c46_l77_assert_trap() { let mut instance = create_module_1(); - let result = c46_l77_action_invoke(&mut*instance); + let result = c46_l77_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -587,7 +596,12 @@ fn c48_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 81 fn c49_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c49_l81_action_invoke"); - let result = instance.call("i32.trunc_u_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "i32.trunc_u_f32", + &[Value::F32( + (0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -595,7 +609,12 @@ fn c49_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 82 fn c50_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c50_l82_action_invoke"); - let result = instance.call("i32.trunc_u_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "i32.trunc_u_f32", + &[Value::F32( + (-0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -676,14 +695,14 @@ fn c59_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c60_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c60_l92_action_invoke"); let result = instance.call("i32.trunc_u_f32", &[Value::F32((4294967300.0f32))]); - + result.map(|_| ()) } #[test] fn c60_l92_assert_trap() { let mut instance = create_module_1(); - let result = c60_l92_action_invoke(&mut*instance); + let result = c60_l92_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -691,14 +710,14 @@ fn c60_l92_assert_trap() { fn c61_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c61_l93_action_invoke"); let result = instance.call("i32.trunc_u_f32", &[Value::F32((-1.0f32))]); - + result.map(|_| ()) } #[test] fn c61_l93_assert_trap() { let mut instance = create_module_1(); - let result = c61_l93_action_invoke(&mut*instance); + let result = c61_l93_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -706,14 +725,14 @@ fn c61_l93_assert_trap() { fn c62_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c62_l94_action_invoke"); let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::INFINITY)]); - + result.map(|_| ()) } #[test] fn c62_l94_assert_trap() { let mut instance = create_module_1(); - let result = c62_l94_action_invoke(&mut*instance); + let result = c62_l94_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -721,14 +740,14 @@ fn c62_l94_assert_trap() { fn c63_l95_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c63_l95_action_invoke"); let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::NEG_INFINITY)]); - + result.map(|_| ()) } #[test] fn c63_l95_assert_trap() { let mut instance = create_module_1(); - let result = c63_l95_action_invoke(&mut*instance); + let result = c63_l95_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -736,14 +755,14 @@ fn c63_l95_assert_trap() { fn c64_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c64_l96_action_invoke"); let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::from_bits(2143289344))]); - + result.map(|_| ()) } #[test] fn c64_l96_assert_trap() { let mut instance = create_module_1(); - let result = c64_l96_action_invoke(&mut*instance); + let result = c64_l96_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -751,14 +770,14 @@ fn c64_l96_assert_trap() { fn c65_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c65_l97_action_invoke"); let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::from_bits(2141192192))]); - + result.map(|_| ()) } #[test] fn c65_l97_assert_trap() { let mut instance = create_module_1(); - let result = c65_l97_action_invoke(&mut*instance); + let result = c65_l97_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -766,14 +785,14 @@ fn c65_l97_assert_trap() { fn c66_l98_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c66_l98_action_invoke"); let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::from_bits(4290772992))]); - + result.map(|_| ()) } #[test] fn c66_l98_assert_trap() { let mut instance = create_module_1(); - let result = c66_l98_action_invoke(&mut*instance); + let result = c66_l98_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -781,14 +800,14 @@ fn c66_l98_assert_trap() { fn c67_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c67_l99_action_invoke"); let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::from_bits(4288675840))]); - + result.map(|_| ()) } #[test] fn c67_l99_assert_trap() { let mut instance = create_module_1(); - let result = c67_l99_action_invoke(&mut*instance); + let result = c67_l99_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -908,14 +927,14 @@ fn c81_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c82_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c82_l115_action_invoke"); let result = instance.call("i32.trunc_s_f64", &[Value::F64((2147483648.0f64))]); - + result.map(|_| ()) } #[test] fn c82_l115_assert_trap() { let mut instance = create_module_1(); - let result = c82_l115_action_invoke(&mut*instance); + let result = c82_l115_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -923,14 +942,14 @@ fn c82_l115_assert_trap() { fn c83_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c83_l116_action_invoke"); let result = instance.call("i32.trunc_s_f64", &[Value::F64((-2147483649.0f64))]); - + result.map(|_| ()) } #[test] fn c83_l116_assert_trap() { let mut instance = create_module_1(); - let result = c83_l116_action_invoke(&mut*instance); + let result = c83_l116_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -938,14 +957,14 @@ fn c83_l116_assert_trap() { fn c84_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c84_l117_action_invoke"); let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::INFINITY)]); - + result.map(|_| ()) } #[test] fn c84_l117_assert_trap() { let mut instance = create_module_1(); - let result = c84_l117_action_invoke(&mut*instance); + let result = c84_l117_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -953,74 +972,86 @@ fn c84_l117_assert_trap() { fn c85_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c85_l118_action_invoke"); let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::NEG_INFINITY)]); - + result.map(|_| ()) } #[test] fn c85_l118_assert_trap() { let mut instance = create_module_1(); - let result = c85_l118_action_invoke(&mut*instance); + let result = c85_l118_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 119 fn c86_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c86_l119_action_invoke"); - let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(9221120237041090560))]); - + let result = instance.call( + "i32.trunc_s_f64", + &[Value::F64(f64::from_bits(9221120237041090560))], + ); + result.map(|_| ()) } #[test] fn c86_l119_assert_trap() { let mut instance = create_module_1(); - let result = c86_l119_action_invoke(&mut*instance); + let result = c86_l119_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 120 fn c87_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c87_l120_action_invoke"); - let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(9219994337134247936))]); - + let result = instance.call( + "i32.trunc_s_f64", + &[Value::F64(f64::from_bits(9219994337134247936))], + ); + result.map(|_| ()) } #[test] fn c87_l120_assert_trap() { let mut instance = create_module_1(); - let result = c87_l120_action_invoke(&mut*instance); + let result = c87_l120_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 121 fn c88_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c88_l121_action_invoke"); - let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(18444492273895866368))]); - + let result = instance.call( + "i32.trunc_s_f64", + &[Value::F64(f64::from_bits(18444492273895866368))], + ); + result.map(|_| ()) } #[test] fn c88_l121_assert_trap() { let mut instance = create_module_1(); - let result = c88_l121_action_invoke(&mut*instance); + let result = c88_l121_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 122 fn c89_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c89_l122_action_invoke"); - let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(18443366373989023744))]); - + let result = instance.call( + "i32.trunc_s_f64", + &[Value::F64(f64::from_bits(18443366373989023744))], + ); + result.map(|_| ()) } #[test] fn c89_l122_assert_trap() { let mut instance = create_module_1(); - let result = c89_l122_action_invoke(&mut*instance); + let result = c89_l122_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1140,14 +1171,14 @@ fn c103_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c104_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c104_l138_action_invoke"); let result = instance.call("i32.trunc_u_f64", &[Value::F64((4294967296.0f64))]); - + result.map(|_| ()) } #[test] fn c104_l138_assert_trap() { let mut instance = create_module_1(); - let result = c104_l138_action_invoke(&mut*instance); + let result = c104_l138_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1155,14 +1186,14 @@ fn c104_l138_assert_trap() { fn c105_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c105_l139_action_invoke"); let result = instance.call("i32.trunc_u_f64", &[Value::F64((-1.0f64))]); - + result.map(|_| ()) } #[test] fn c105_l139_assert_trap() { let mut instance = create_module_1(); - let result = c105_l139_action_invoke(&mut*instance); + let result = c105_l139_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1170,29 +1201,32 @@ fn c105_l139_assert_trap() { fn c106_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c106_l140_action_invoke"); let result = instance.call("i32.trunc_u_f64", &[Value::F64((10000000000000000.0f64))]); - + result.map(|_| ()) } #[test] fn c106_l140_assert_trap() { let mut instance = create_module_1(); - let result = c106_l140_action_invoke(&mut*instance); + let result = c106_l140_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 141 fn c107_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c107_l141_action_invoke"); - let result = instance.call("i32.trunc_u_f64", &[Value::F64((1000000000000000000000000000000.0f64))]); - + let result = instance.call( + "i32.trunc_u_f64", + &[Value::F64((1000000000000000000000000000000.0f64))], + ); + result.map(|_| ()) } #[test] fn c107_l141_assert_trap() { let mut instance = create_module_1(); - let result = c107_l141_action_invoke(&mut*instance); + let result = c107_l141_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1200,14 +1234,14 @@ fn c107_l141_assert_trap() { fn c108_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c108_l142_action_invoke"); let result = instance.call("i32.trunc_u_f64", &[Value::F64((9223372036854776000.0f64))]); - + result.map(|_| ()) } #[test] fn c108_l142_assert_trap() { let mut instance = create_module_1(); - let result = c108_l142_action_invoke(&mut*instance); + let result = c108_l142_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1215,14 +1249,14 @@ fn c108_l142_assert_trap() { fn c109_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c109_l143_action_invoke"); let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::INFINITY)]); - + result.map(|_| ()) } #[test] fn c109_l143_assert_trap() { let mut instance = create_module_1(); - let result = c109_l143_action_invoke(&mut*instance); + let result = c109_l143_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1230,74 +1264,86 @@ fn c109_l143_assert_trap() { fn c110_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c110_l144_action_invoke"); let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::NEG_INFINITY)]); - + result.map(|_| ()) } #[test] fn c110_l144_assert_trap() { let mut instance = create_module_1(); - let result = c110_l144_action_invoke(&mut*instance); + let result = c110_l144_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 145 fn c111_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c111_l145_action_invoke"); - let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(9221120237041090560))]); - + let result = instance.call( + "i32.trunc_u_f64", + &[Value::F64(f64::from_bits(9221120237041090560))], + ); + result.map(|_| ()) } #[test] fn c111_l145_assert_trap() { let mut instance = create_module_1(); - let result = c111_l145_action_invoke(&mut*instance); + let result = c111_l145_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 146 fn c112_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c112_l146_action_invoke"); - let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(9219994337134247936))]); - + let result = instance.call( + "i32.trunc_u_f64", + &[Value::F64(f64::from_bits(9219994337134247936))], + ); + result.map(|_| ()) } #[test] fn c112_l146_assert_trap() { let mut instance = create_module_1(); - let result = c112_l146_action_invoke(&mut*instance); + let result = c112_l146_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 147 fn c113_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c113_l147_action_invoke"); - let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(18444492273895866368))]); - + let result = instance.call( + "i32.trunc_u_f64", + &[Value::F64(f64::from_bits(18444492273895866368))], + ); + result.map(|_| ()) } #[test] fn c113_l147_assert_trap() { let mut instance = create_module_1(); - let result = c113_l147_action_invoke(&mut*instance); + let result = c113_l147_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 148 fn c114_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c114_l148_action_invoke"); - let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(18443366373989023744))]); - + let result = instance.call( + "i32.trunc_u_f64", + &[Value::F64(f64::from_bits(18443366373989023744))], + ); + result.map(|_| ()) } #[test] fn c114_l148_assert_trap() { let mut instance = create_module_1(); - let result = c114_l148_action_invoke(&mut*instance); + let result = c114_l148_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1320,7 +1366,12 @@ fn c116_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 152 fn c117_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c117_l152_action_invoke"); - let result = instance.call("i64.trunc_s_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "i64.trunc_s_f32", + &[Value::F32( + (0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -1328,7 +1379,12 @@ fn c117_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 153 fn c118_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c118_l153_action_invoke"); - let result = instance.call("i64.trunc_s_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "i64.trunc_s_f32", + &[Value::F32( + (-0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -1424,7 +1480,10 @@ fn c129_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 165 fn c130_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c130_l165_action_invoke"); - let result = instance.call("i64.trunc_s_f32", &[Value::F32((-9223372000000000000.0f32))]); + let result = instance.call( + "i64.trunc_s_f32", + &[Value::F32((-9223372000000000000.0f32))], + ); assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); result.map(|_| ()) } @@ -1433,29 +1492,32 @@ fn c130_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c131_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c131_l166_action_invoke"); let result = instance.call("i64.trunc_s_f32", &[Value::F32((9223372000000000000.0f32))]); - + result.map(|_| ()) } #[test] fn c131_l166_assert_trap() { let mut instance = create_module_1(); - let result = c131_l166_action_invoke(&mut*instance); + let result = c131_l166_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 167 fn c132_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c132_l167_action_invoke"); - let result = instance.call("i64.trunc_s_f32", &[Value::F32((-9223373000000000000.0f32))]); - + let result = instance.call( + "i64.trunc_s_f32", + &[Value::F32((-9223373000000000000.0f32))], + ); + result.map(|_| ()) } #[test] fn c132_l167_assert_trap() { let mut instance = create_module_1(); - let result = c132_l167_action_invoke(&mut*instance); + let result = c132_l167_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1463,14 +1525,14 @@ fn c132_l167_assert_trap() { fn c133_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c133_l168_action_invoke"); let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::INFINITY)]); - + result.map(|_| ()) } #[test] fn c133_l168_assert_trap() { let mut instance = create_module_1(); - let result = c133_l168_action_invoke(&mut*instance); + let result = c133_l168_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1478,14 +1540,14 @@ fn c133_l168_assert_trap() { fn c134_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c134_l169_action_invoke"); let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::NEG_INFINITY)]); - + result.map(|_| ()) } #[test] fn c134_l169_assert_trap() { let mut instance = create_module_1(); - let result = c134_l169_action_invoke(&mut*instance); + let result = c134_l169_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1493,14 +1555,14 @@ fn c134_l169_assert_trap() { fn c135_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c135_l170_action_invoke"); let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::from_bits(2143289344))]); - + result.map(|_| ()) } #[test] fn c135_l170_assert_trap() { let mut instance = create_module_1(); - let result = c135_l170_action_invoke(&mut*instance); + let result = c135_l170_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1508,14 +1570,14 @@ fn c135_l170_assert_trap() { fn c136_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c136_l171_action_invoke"); let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::from_bits(2141192192))]); - + result.map(|_| ()) } #[test] fn c136_l171_assert_trap() { let mut instance = create_module_1(); - let result = c136_l171_action_invoke(&mut*instance); + let result = c136_l171_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1523,14 +1585,14 @@ fn c136_l171_assert_trap() { fn c137_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c137_l172_action_invoke"); let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::from_bits(4290772992))]); - + result.map(|_| ()) } #[test] fn c137_l172_assert_trap() { let mut instance = create_module_1(); - let result = c137_l172_action_invoke(&mut*instance); + let result = c137_l172_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1538,14 +1600,14 @@ fn c137_l172_assert_trap() { fn c138_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c138_l173_action_invoke"); let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::from_bits(4288675840))]); - + result.map(|_| ()) } #[test] fn c138_l173_assert_trap() { let mut instance = create_module_1(); - let result = c138_l173_action_invoke(&mut*instance); + let result = c138_l173_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1568,7 +1630,12 @@ fn c140_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 177 fn c141_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c141_l177_action_invoke"); - let result = instance.call("i64.trunc_u_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "i64.trunc_u_f32", + &[Value::F32( + (0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -1576,7 +1643,12 @@ fn c141_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 178 fn c142_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c142_l178_action_invoke"); - let result = instance.call("i64.trunc_u_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "i64.trunc_u_f32", + &[Value::F32( + (-0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -1616,7 +1688,10 @@ fn c146_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 183 fn c147_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c147_l183_action_invoke"); - let result = instance.call("i64.trunc_u_f32", &[Value::F32((18446743000000000000.0f32))]); + let result = instance.call( + "i64.trunc_u_f32", + &[Value::F32((18446743000000000000.0f32))], + ); assert_eq!(result, Ok(Some(Value::I64(-1099511627776 as i64)))); result.map(|_| ()) } @@ -1640,15 +1715,18 @@ fn c149_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 186 fn c150_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c150_l186_action_invoke"); - let result = instance.call("i64.trunc_u_f32", &[Value::F32((18446744000000000000.0f32))]); - + let result = instance.call( + "i64.trunc_u_f32", + &[Value::F32((18446744000000000000.0f32))], + ); + result.map(|_| ()) } #[test] fn c150_l186_assert_trap() { let mut instance = create_module_1(); - let result = c150_l186_action_invoke(&mut*instance); + let result = c150_l186_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1656,14 +1734,14 @@ fn c150_l186_assert_trap() { fn c151_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c151_l187_action_invoke"); let result = instance.call("i64.trunc_u_f32", &[Value::F32((-1.0f32))]); - + result.map(|_| ()) } #[test] fn c151_l187_assert_trap() { let mut instance = create_module_1(); - let result = c151_l187_action_invoke(&mut*instance); + let result = c151_l187_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1671,14 +1749,14 @@ fn c151_l187_assert_trap() { fn c152_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c152_l188_action_invoke"); let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::INFINITY)]); - + result.map(|_| ()) } #[test] fn c152_l188_assert_trap() { let mut instance = create_module_1(); - let result = c152_l188_action_invoke(&mut*instance); + let result = c152_l188_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1686,14 +1764,14 @@ fn c152_l188_assert_trap() { fn c153_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c153_l189_action_invoke"); let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::NEG_INFINITY)]); - + result.map(|_| ()) } #[test] fn c153_l189_assert_trap() { let mut instance = create_module_1(); - let result = c153_l189_action_invoke(&mut*instance); + let result = c153_l189_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1701,14 +1779,14 @@ fn c153_l189_assert_trap() { fn c154_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c154_l190_action_invoke"); let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::from_bits(2143289344))]); - + result.map(|_| ()) } #[test] fn c154_l190_assert_trap() { let mut instance = create_module_1(); - let result = c154_l190_action_invoke(&mut*instance); + let result = c154_l190_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1716,14 +1794,14 @@ fn c154_l190_assert_trap() { fn c155_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c155_l191_action_invoke"); let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::from_bits(2141192192))]); - + result.map(|_| ()) } #[test] fn c155_l191_assert_trap() { let mut instance = create_module_1(); - let result = c155_l191_action_invoke(&mut*instance); + let result = c155_l191_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1731,14 +1809,14 @@ fn c155_l191_assert_trap() { fn c156_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c156_l192_action_invoke"); let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::from_bits(4290772992))]); - + result.map(|_| ()) } #[test] fn c156_l192_assert_trap() { let mut instance = create_module_1(); - let result = c156_l192_action_invoke(&mut*instance); + let result = c156_l192_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1746,14 +1824,14 @@ fn c156_l192_assert_trap() { fn c157_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c157_l193_action_invoke"); let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::from_bits(4288675840))]); - + result.map(|_| ()) } #[test] fn c157_l193_assert_trap() { let mut instance = create_module_1(); - let result = c157_l193_action_invoke(&mut*instance); + let result = c157_l193_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1880,7 +1958,10 @@ fn c172_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 210 fn c173_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c173_l210_action_invoke"); - let result = instance.call("i64.trunc_s_f64", &[Value::F64((-9223372036854776000.0f64))]); + let result = instance.call( + "i64.trunc_s_f64", + &[Value::F64((-9223372036854776000.0f64))], + ); assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); result.map(|_| ()) } @@ -1889,29 +1970,32 @@ fn c173_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c174_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c174_l211_action_invoke"); let result = instance.call("i64.trunc_s_f64", &[Value::F64((9223372036854776000.0f64))]); - + result.map(|_| ()) } #[test] fn c174_l211_assert_trap() { let mut instance = create_module_1(); - let result = c174_l211_action_invoke(&mut*instance); + let result = c174_l211_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 212 fn c175_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c175_l212_action_invoke"); - let result = instance.call("i64.trunc_s_f64", &[Value::F64((-9223372036854778000.0f64))]); - + let result = instance.call( + "i64.trunc_s_f64", + &[Value::F64((-9223372036854778000.0f64))], + ); + result.map(|_| ()) } #[test] fn c175_l212_assert_trap() { let mut instance = create_module_1(); - let result = c175_l212_action_invoke(&mut*instance); + let result = c175_l212_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1919,14 +2003,14 @@ fn c175_l212_assert_trap() { fn c176_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c176_l213_action_invoke"); let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::INFINITY)]); - + result.map(|_| ()) } #[test] fn c176_l213_assert_trap() { let mut instance = create_module_1(); - let result = c176_l213_action_invoke(&mut*instance); + let result = c176_l213_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1934,74 +2018,86 @@ fn c176_l213_assert_trap() { fn c177_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c177_l214_action_invoke"); let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::NEG_INFINITY)]); - + result.map(|_| ()) } #[test] fn c177_l214_assert_trap() { let mut instance = create_module_1(); - let result = c177_l214_action_invoke(&mut*instance); + let result = c177_l214_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 215 fn c178_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c178_l215_action_invoke"); - let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(9221120237041090560))]); - + let result = instance.call( + "i64.trunc_s_f64", + &[Value::F64(f64::from_bits(9221120237041090560))], + ); + result.map(|_| ()) } #[test] fn c178_l215_assert_trap() { let mut instance = create_module_1(); - let result = c178_l215_action_invoke(&mut*instance); + let result = c178_l215_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 216 fn c179_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c179_l216_action_invoke"); - let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(9219994337134247936))]); - + let result = instance.call( + "i64.trunc_s_f64", + &[Value::F64(f64::from_bits(9219994337134247936))], + ); + result.map(|_| ()) } #[test] fn c179_l216_assert_trap() { let mut instance = create_module_1(); - let result = c179_l216_action_invoke(&mut*instance); + let result = c179_l216_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 217 fn c180_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c180_l217_action_invoke"); - let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(18444492273895866368))]); - + let result = instance.call( + "i64.trunc_s_f64", + &[Value::F64(f64::from_bits(18444492273895866368))], + ); + result.map(|_| ()) } #[test] fn c180_l217_assert_trap() { let mut instance = create_module_1(); - let result = c180_l217_action_invoke(&mut*instance); + let result = c180_l217_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 218 fn c181_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c181_l218_action_invoke"); - let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(18443366373989023744))]); - + let result = instance.call( + "i64.trunc_s_f64", + &[Value::F64(f64::from_bits(18443366373989023744))], + ); + result.map(|_| ()) } #[test] fn c181_l218_assert_trap() { let mut instance = create_module_1(); - let result = c181_l218_action_invoke(&mut*instance); + let result = c181_l218_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2080,7 +2176,10 @@ fn c190_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 229 fn c191_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c191_l229_action_invoke"); - let result = instance.call("i64.trunc_u_f64", &[Value::F64((18446744073709550000.0f64))]); + let result = instance.call( + "i64.trunc_u_f64", + &[Value::F64((18446744073709550000.0f64))], + ); assert_eq!(result, Ok(Some(Value::I64(-2048 as i64)))); result.map(|_| ()) } @@ -2128,15 +2227,18 @@ fn c196_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 235 fn c197_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c197_l235_action_invoke"); - let result = instance.call("i64.trunc_u_f64", &[Value::F64((18446744073709552000.0f64))]); - + let result = instance.call( + "i64.trunc_u_f64", + &[Value::F64((18446744073709552000.0f64))], + ); + result.map(|_| ()) } #[test] fn c197_l235_assert_trap() { let mut instance = create_module_1(); - let result = c197_l235_action_invoke(&mut*instance); + let result = c197_l235_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2144,14 +2246,14 @@ fn c197_l235_assert_trap() { fn c198_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c198_l236_action_invoke"); let result = instance.call("i64.trunc_u_f64", &[Value::F64((-1.0f64))]); - + result.map(|_| ()) } #[test] fn c198_l236_assert_trap() { let mut instance = create_module_1(); - let result = c198_l236_action_invoke(&mut*instance); + let result = c198_l236_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2159,14 +2261,14 @@ fn c198_l236_assert_trap() { fn c199_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c199_l237_action_invoke"); let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::INFINITY)]); - + result.map(|_| ()) } #[test] fn c199_l237_assert_trap() { let mut instance = create_module_1(); - let result = c199_l237_action_invoke(&mut*instance); + let result = c199_l237_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2174,74 +2276,86 @@ fn c199_l237_assert_trap() { fn c200_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c200_l238_action_invoke"); let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::NEG_INFINITY)]); - + result.map(|_| ()) } #[test] fn c200_l238_assert_trap() { let mut instance = create_module_1(); - let result = c200_l238_action_invoke(&mut*instance); + let result = c200_l238_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 239 fn c201_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c201_l239_action_invoke"); - let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(9221120237041090560))]); - + let result = instance.call( + "i64.trunc_u_f64", + &[Value::F64(f64::from_bits(9221120237041090560))], + ); + result.map(|_| ()) } #[test] fn c201_l239_assert_trap() { let mut instance = create_module_1(); - let result = c201_l239_action_invoke(&mut*instance); + let result = c201_l239_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 240 fn c202_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c202_l240_action_invoke"); - let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(9219994337134247936))]); - + let result = instance.call( + "i64.trunc_u_f64", + &[Value::F64(f64::from_bits(9219994337134247936))], + ); + result.map(|_| ()) } #[test] fn c202_l240_assert_trap() { let mut instance = create_module_1(); - let result = c202_l240_action_invoke(&mut*instance); + let result = c202_l240_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 241 fn c203_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c203_l241_action_invoke"); - let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(18444492273895866368))]); - + let result = instance.call( + "i64.trunc_u_f64", + &[Value::F64(f64::from_bits(18444492273895866368))], + ); + result.map(|_| ()) } #[test] fn c203_l241_assert_trap() { let mut instance = create_module_1(); - let result = c203_l241_action_invoke(&mut*instance); + let result = c203_l241_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 242 fn c204_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c204_l242_action_invoke"); - let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(18443366373989023744))]); - + let result = instance.call( + "i64.trunc_u_f64", + &[Value::F64(f64::from_bits(18443366373989023744))], + ); + result.map(|_| ()) } #[test] fn c204_l242_assert_trap() { let mut instance = create_module_1(); - let result = c204_l242_action_invoke(&mut*instance); + let result = c204_l242_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2352,7 +2466,10 @@ fn c217_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 259 fn c218_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c218_l259_action_invoke"); - let result = instance.call("f32.convert_s_i64", &[Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "f32.convert_s_i64", + &[Value::I64(9223372036854775807 as i64)], + ); assert_eq!(result, Ok(Some(Value::F32((9223372000000000000.0f32))))); result.map(|_| ()) } @@ -2360,7 +2477,10 @@ fn c218_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 260 fn c219_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c219_l260_action_invoke"); - let result = instance.call("f32.convert_s_i64", &[Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "f32.convert_s_i64", + &[Value::I64(-9223372036854775808 as i64)], + ); assert_eq!(result, Ok(Some(Value::F32((-9223372000000000000.0f32))))); result.map(|_| ()) } @@ -2480,7 +2600,10 @@ fn c233_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 278 fn c234_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c234_l278_action_invoke"); - let result = instance.call("f64.convert_s_i64", &[Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "f64.convert_s_i64", + &[Value::I64(9223372036854775807 as i64)], + ); assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64))))); result.map(|_| ()) } @@ -2488,7 +2611,10 @@ fn c234_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 279 fn c235_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c235_l279_action_invoke"); - let result = instance.call("f64.convert_s_i64", &[Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "f64.convert_s_i64", + &[Value::I64(-9223372036854775808 as i64)], + ); assert_eq!(result, Ok(Some(Value::F64((-9223372036854776000.0f64))))); result.map(|_| ()) } @@ -2664,7 +2790,10 @@ fn c256_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 305 fn c257_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c257_l305_action_invoke"); - let result = instance.call("f32.convert_u_i64", &[Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "f32.convert_u_i64", + &[Value::I64(9223372036854775807 as i64)], + ); assert_eq!(result, Ok(Some(Value::F32((9223372000000000000.0f32))))); result.map(|_| ()) } @@ -2672,7 +2801,10 @@ fn c257_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 306 fn c258_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c258_l306_action_invoke"); - let result = instance.call("f32.convert_u_i64", &[Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "f32.convert_u_i64", + &[Value::I64(-9223372036854775808 as i64)], + ); assert_eq!(result, Ok(Some(Value::F32((9223372000000000000.0f32))))); result.map(|_| ()) } @@ -2760,7 +2892,10 @@ fn c268_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 320 fn c269_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c269_l320_action_invoke"); - let result = instance.call("f64.convert_u_i64", &[Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "f64.convert_u_i64", + &[Value::I64(9223372036854775807 as i64)], + ); assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64))))); result.map(|_| ()) } @@ -2768,7 +2903,10 @@ fn c269_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 321 fn c270_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c270_l321_action_invoke"); - let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "f64.convert_u_i64", + &[Value::I64(-9223372036854775808 as i64)], + ); assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64))))); result.map(|_| ()) } @@ -2784,7 +2922,10 @@ fn c271_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 323 fn c272_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c272_l323_action_invoke"); - let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854774784 as i64)]); + let result = instance.call( + "f64.convert_u_i64", + &[Value::I64(-9223372036854774784 as i64)], + ); assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64))))); result.map(|_| ()) } @@ -2792,7 +2933,10 @@ fn c272_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 324 fn c273_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c273_l324_action_invoke"); - let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854774783 as i64)]); + let result = instance.call( + "f64.convert_u_i64", + &[Value::I64(-9223372036854774783 as i64)], + ); assert_eq!(result, Ok(Some(Value::F64((9223372036854778000.0f64))))); result.map(|_| ()) } @@ -2800,7 +2944,10 @@ fn c273_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 325 fn c274_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c274_l325_action_invoke"); - let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854774782 as i64)]); + let result = instance.call( + "f64.convert_u_i64", + &[Value::I64(-9223372036854774782 as i64)], + ); assert_eq!(result, Ok(Some(Value::F64((9223372036854778000.0f64))))); result.map(|_| ()) } @@ -2864,16 +3011,36 @@ fn c281_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 335 fn c282_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c282_l335_action_invoke"); - let result = instance.call("f64.promote_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000001401298464324817f64))))); + let result = instance.call( + "f64.promote_f32", + &[Value::F32( + (0.000000000000000000000000000000000000000000001f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.000000000000000000000000000000000000000000001401298464324817f64) + ))) + ); result.map(|_| ()) } // Line 336 fn c283_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c283_l336_action_invoke"); - let result = instance.call("f64.promote_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000001401298464324817f64))))); + let result = instance.call( + "f64.promote_f32", + &[Value::F32( + (-0.000000000000000000000000000000000000000000001f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.000000000000000000000000000000000000000000001401298464324817f64) + ))) + ); result.map(|_| ()) } @@ -2896,32 +3063,66 @@ fn c285_l338_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 339 fn c286_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c286_l339_action_invoke"); - let result = instance.call("f64.promote_f32", &[Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F64((-340282346638528860000000000000000000000.0f64))))); + let result = instance.call( + "f64.promote_f32", + &[Value::F32((-340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (-340282346638528860000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } // Line 340 fn c287_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c287_l340_action_invoke"); - let result = instance.call("f64.promote_f32", &[Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F64((340282346638528860000000000000000000000.0f64))))); + let result = instance.call( + "f64.promote_f32", + &[Value::F32((340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (340282346638528860000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } // Line 342 fn c288_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c288_l342_action_invoke"); - let result = instance.call("f64.promote_f32", &[Value::F32((0.0000000000000000000000000000000000015046328f32))]); - assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000001504632769052528f64))))); + let result = instance.call( + "f64.promote_f32", + &[Value::F32( + (0.0000000000000000000000000000000000015046328f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.000000000000000000000000000000000001504632769052528f64) + ))) + ); result.map(|_| ()) } // Line 344 fn c289_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c289_l344_action_invoke"); - let result = instance.call("f64.promote_f32", &[Value::F32((66382537000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F64((66382536710104395000000000000000000000.0f64))))); + let result = instance.call( + "f64.promote_f32", + &[Value::F32((66382537000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (66382536710104395000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -2943,45 +3144,69 @@ fn c291_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 347 fn c292_l347_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c292_l347_assert_return_canonical_nan"); - let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c292_l347_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c292_l347_assert_return_canonical_nan" + ); + let result = instance + .call("f64.promote_f32", &[Value::F32(f32::from_bits(2143289344))]) + .unwrap() + .expect("Missing result in c292_l347_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 348 fn c293_l348_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c293_l348_assert_return_arithmetic_nan"); - let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c293_l348_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c293_l348_assert_return_arithmetic_nan" + ); + let result = instance + .call("f64.promote_f32", &[Value::F32(f32::from_bits(2141192192))]) + .unwrap() + .expect("Missing result in c293_l348_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 349 fn c294_l349_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c294_l349_assert_return_canonical_nan"); - let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c294_l349_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c294_l349_assert_return_canonical_nan" + ); + let result = instance + .call("f64.promote_f32", &[Value::F32(f32::from_bits(4290772992))]) + .unwrap() + .expect("Missing result in c294_l349_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 350 fn c295_l350_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c295_l350_assert_return_arithmetic_nan"); - let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c295_l350_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c295_l350_assert_return_arithmetic_nan" + ); + let result = instance + .call("f64.promote_f32", &[Value::F32(f32::from_bits(4288675840))]) + .unwrap() + .expect("Missing result in c295_l350_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -3036,119 +3261,246 @@ fn c301_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 358 fn c302_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c302_l358_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000011754942807573643f64))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64( + (0.000000000000000000000000000000000000011754942807573643f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 359 fn c303_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c303_l359_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((-0.000000000000000000000000000000000000011754942807573643f64))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64( + (-0.000000000000000000000000000000000000011754942807573643f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 360 fn c304_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c304_l360_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000011754942807573642f64))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64( + (0.000000000000000000000000000000000000011754942807573642f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754942f32) + ))) + ); result.map(|_| ()) } // Line 361 fn c305_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c305_l361_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((-0.000000000000000000000000000000000000011754942807573642f64))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64( + (-0.000000000000000000000000000000000000011754942807573642f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754942f32) + ))) + ); result.map(|_| ()) } // Line 362 fn c306_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c306_l362_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000000000001401298464324817f64))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64( + (0.000000000000000000000000000000000000000000001401298464324817f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 363 fn c307_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c307_l363_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((-0.000000000000000000000000000000000000000000001401298464324817f64))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64( + (-0.000000000000000000000000000000000000000000001401298464324817f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 364 fn c308_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c308_l364_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((340282336497324060000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F32((340282330000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64((340282336497324060000000000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282330000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 365 fn c309_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c309_l365_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((-340282336497324060000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F32((-340282330000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64((-340282336497324060000000000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282330000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 366 fn c310_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c310_l366_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((340282336497324100000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64((340282336497324100000000000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 367 fn c311_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c311_l367_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((-340282336497324100000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64((-340282336497324100000000000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 368 fn c312_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c312_l368_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((340282346638528860000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64((340282346638528860000000000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 369 fn c313_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c313_l369_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((-340282346638528860000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64((-340282346638528860000000000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 370 fn c314_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c314_l370_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((340282356779733620000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64((340282356779733620000000000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 371 fn c315_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c315_l371_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((-340282356779733620000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64((-340282356779733620000000000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 372 fn c316_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c316_l372_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((340282356779733660000000000000000000000.0f64))]); + let result = instance.call( + "f32.demote_f64", + &[Value::F64((340282356779733660000000000000000000000.0f64))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -3156,7 +3508,10 @@ fn c316_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 373 fn c317_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c317_l373_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((-340282356779733660000000000000000000000.0f64))]); + let result = instance.call( + "f32.demote_f64", + &[Value::F64((-340282356779733660000000000000000000000.0f64))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -3164,16 +3519,34 @@ fn c317_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 374 fn c318_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c318_l374_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000001504632769052528f64))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000015046328f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64( + (0.000000000000000000000000000000000001504632769052528f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.0000000000000000000000000000000000015046328f32) + ))) + ); result.map(|_| ()) } // Line 375 fn c319_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c319_l375_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((66382536710104395000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F32((66382537000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64((66382536710104395000000000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (66382537000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -3284,24 +3657,50 @@ fn c332_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 389 fn c333_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c333_l389_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((424258443299142700000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F32((424258450000000000000000000000000.0f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64((424258443299142700000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((424258450000000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 390 fn c334_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c334_l390_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((0.0000000000000000000000000000000001569262107843488f64))]); - assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000015692621f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64( + (0.0000000000000000000000000000000001569262107843488f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.00000000000000000000000000000000015692621f32) + ))) + ); result.map(|_| ()) } // Line 391 fn c335_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c335_l391_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000010551773688605172f64))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000010551773f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64( + (0.000000000000000000000000000000000000010551773688605172f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000010551773f32) + ))) + ); result.map(|_| ()) } @@ -3316,52 +3715,94 @@ fn c336_l392_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 393 fn c337_l393_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c337_l393_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((-9063376370095757000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F32((-9063376000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64((-9063376370095757000000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-9063376000000000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 394 fn c338_l394_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c338_l394_assert_return_canonical_nan"); - let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c338_l394_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c338_l394_assert_return_canonical_nan" + ); + let result = instance + .call( + "f32.demote_f64", + &[Value::F64(f64::from_bits(9221120237041090560))], + ) + .unwrap() + .expect("Missing result in c338_l394_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 395 fn c339_l395_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c339_l395_assert_return_arithmetic_nan"); - let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c339_l395_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c339_l395_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f32.demote_f64", + &[Value::F64(f64::from_bits(9219994337134247936))], + ) + .unwrap() + .expect("Missing result in c339_l395_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 396 fn c340_l396_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c340_l396_assert_return_canonical_nan"); - let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c340_l396_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c340_l396_assert_return_canonical_nan" + ); + let result = instance + .call( + "f32.demote_f64", + &[Value::F64(f64::from_bits(18444492273895866368))], + ) + .unwrap() + .expect("Missing result in c340_l396_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 397 fn c341_l397_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c341_l397_assert_return_arithmetic_nan"); - let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c341_l397_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c341_l397_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f32.demote_f64", + &[Value::F64(f64::from_bits(18443366373989023744))], + ) + .unwrap() + .expect("Missing result in c341_l397_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -3384,7 +3825,12 @@ fn c343_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 400 fn c344_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c344_l400_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((0.0000000000000000000000000000000000000000000007006492321624085f64))]); + let result = instance.call( + "f32.demote_f64", + &[Value::F64( + (0.0000000000000000000000000000000000000000000007006492321624085f64), + )], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -3392,7 +3838,12 @@ fn c344_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 401 fn c345_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c345_l401_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((-0.0000000000000000000000000000000000000000000007006492321624085f64))]); + let result = instance.call( + "f32.demote_f64", + &[Value::F64( + (-0.0000000000000000000000000000000000000000000007006492321624085f64), + )], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -3400,16 +3851,36 @@ fn c345_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 402 fn c346_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c346_l402_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((0.0000000000000000000000000000000000000000000007006492321624087f64))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64( + (0.0000000000000000000000000000000000000000000007006492321624087f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 403 fn c347_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c347_l403_action_invoke"); - let result = instance.call("f32.demote_f64", &[Value::F64((-0.0000000000000000000000000000000000000000000007006492321624087f64))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "f32.demote_f64", + &[Value::F64( + (-0.0000000000000000000000000000000000000000000007006492321624087f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } @@ -3433,7 +3904,12 @@ fn c349_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c350_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c350_l407_action_invoke"); let result = instance.call("f32.reinterpret_i32", &[Value::I32(1 as i32)]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } @@ -3442,12 +3918,15 @@ fn c351_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c351_l408_action_invoke"); let result = instance.call("f32.reinterpret_i32", &[Value::I32(-1 as i32)]); let expected = f32::from_bits(4294967295); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3455,7 +3934,12 @@ fn c351_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c352_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c352_l409_action_invoke"); let result = instance.call("f32.reinterpret_i32", &[Value::I32(123456789 as i32)]); - assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000016535997f32))))); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.00000000000000000000000000000000016535997f32) + ))) + ); result.map(|_| ()) } @@ -3463,7 +3947,12 @@ fn c352_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c353_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c353_l410_action_invoke"); let result = instance.call("f32.reinterpret_i32", &[Value::I32(-2147483647 as i32)]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } @@ -3488,12 +3977,15 @@ fn c356_l413_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c356_l413_action_invoke"); let result = instance.call("f32.reinterpret_i32", &[Value::I32(2143289344 as i32)]); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3502,12 +3994,15 @@ fn c357_l414_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c357_l414_action_invoke"); let result = instance.call("f32.reinterpret_i32", &[Value::I32(-4194304 as i32)]); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3516,12 +4011,15 @@ fn c358_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c358_l415_action_invoke"); let result = instance.call("f32.reinterpret_i32", &[Value::I32(2141192192 as i32)]); let expected = f32::from_bits(2141192192); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3530,12 +4028,15 @@ fn c359_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c359_l416_action_invoke"); let result = instance.call("f32.reinterpret_i32", &[Value::I32(-6291456 as i32)]); let expected = f32::from_bits(4288675840); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3560,19 +4061,25 @@ fn c362_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c362_l420_action_invoke"); let result = instance.call("f64.reinterpret_i64", &[Value::I64(-1 as i64)]); let expected = f64::from_bits(18446744073709551615); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 421 fn c363_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c363_l421_action_invoke"); - let result = instance.call("f64.reinterpret_i64", &[Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "f64.reinterpret_i64", + &[Value::I64(-9223372036854775808 as i64)], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -3588,7 +4095,10 @@ fn c364_l422_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 423 fn c365_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c365_l423_action_invoke"); - let result = instance.call("f64.reinterpret_i64", &[Value::I64(-9223372036854775807 as i64)]); + let result = instance.call( + "f64.reinterpret_i64", + &[Value::I64(-9223372036854775807 as i64)], + ); assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))))); result.map(|_| ()) } @@ -3596,7 +4106,10 @@ fn c365_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 424 fn c366_l424_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c366_l424_action_invoke"); - let result = instance.call("f64.reinterpret_i64", &[Value::I64(9218868437227405312 as i64)]); + let result = instance.call( + "f64.reinterpret_i64", + &[Value::I64(9218868437227405312 as i64)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -3604,7 +4117,10 @@ fn c366_l424_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 425 fn c367_l425_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c367_l425_action_invoke"); - let result = instance.call("f64.reinterpret_i64", &[Value::I64(-4503599627370496 as i64)]); + let result = instance.call( + "f64.reinterpret_i64", + &[Value::I64(-4503599627370496 as i64)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -3612,56 +4128,80 @@ fn c367_l425_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 426 fn c368_l426_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c368_l426_action_invoke"); - let result = instance.call("f64.reinterpret_i64", &[Value::I64(9221120237041090560 as i64)]); + let result = instance.call( + "f64.reinterpret_i64", + &[Value::I64(9221120237041090560 as i64)], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 427 fn c369_l427_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c369_l427_action_invoke"); - let result = instance.call("f64.reinterpret_i64", &[Value::I64(-2251799813685248 as i64)]); + let result = instance.call( + "f64.reinterpret_i64", + &[Value::I64(-2251799813685248 as i64)], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 428 fn c370_l428_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c370_l428_action_invoke"); - let result = instance.call("f64.reinterpret_i64", &[Value::I64(9219994337134247936 as i64)]); + let result = instance.call( + "f64.reinterpret_i64", + &[Value::I64(9219994337134247936 as i64)], + ); let expected = f64::from_bits(9219994337134247936); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 429 fn c371_l429_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c371_l429_action_invoke"); - let result = instance.call("f64.reinterpret_i64", &[Value::I64(-3377699720527872 as i64)]); + let result = instance.call( + "f64.reinterpret_i64", + &[Value::I64(-3377699720527872 as i64)], + ); let expected = f64::from_bits(18443366373989023744); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3684,7 +4224,12 @@ fn c373_l432_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 433 fn c374_l433_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c374_l433_action_invoke"); - let result = instance.call("i32.reinterpret_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "i32.reinterpret_f32", + &[Value::F32( + (0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3692,7 +4237,10 @@ fn c374_l433_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 434 fn c375_l434_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c375_l434_action_invoke"); - let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(4294967295))]); + let result = instance.call( + "i32.reinterpret_f32", + &[Value::F32(f32::from_bits(4294967295))], + ); assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); result.map(|_| ()) } @@ -3700,7 +4248,12 @@ fn c375_l434_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 435 fn c376_l435_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c376_l435_action_invoke"); - let result = instance.call("i32.reinterpret_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "i32.reinterpret_f32", + &[Value::F32( + (-0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::I32(-2147483647 as i32)))); result.map(|_| ()) } @@ -3724,7 +4277,10 @@ fn c378_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 438 fn c379_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c379_l438_action_invoke"); - let result = instance.call("i32.reinterpret_f32", &[Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "i32.reinterpret_f32", + &[Value::F32((340282350000000000000000000000000000000.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(2139095039 as i32)))); result.map(|_| ()) } @@ -3732,7 +4288,10 @@ fn c379_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 439 fn c380_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c380_l439_action_invoke"); - let result = instance.call("i32.reinterpret_f32", &[Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "i32.reinterpret_f32", + &[Value::F32((-340282350000000000000000000000000000000.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(-8388609 as i32)))); result.map(|_| ()) } @@ -3756,7 +4315,10 @@ fn c382_l441_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 442 fn c383_l442_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c383_l442_action_invoke"); - let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "i32.reinterpret_f32", + &[Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); result.map(|_| ()) } @@ -3764,7 +4326,10 @@ fn c383_l442_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 443 fn c384_l443_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c384_l443_action_invoke"); - let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "i32.reinterpret_f32", + &[Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(-4194304 as i32)))); result.map(|_| ()) } @@ -3772,7 +4337,10 @@ fn c384_l443_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 444 fn c385_l444_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c385_l444_action_invoke"); - let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "i32.reinterpret_f32", + &[Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(2141192192 as i32)))); result.map(|_| ()) } @@ -3780,7 +4348,10 @@ fn c385_l444_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 445 fn c386_l445_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c386_l445_action_invoke"); - let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "i32.reinterpret_f32", + &[Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(-6291456 as i32)))); result.map(|_| ()) } @@ -3812,7 +4383,10 @@ fn c389_l449_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 450 fn c390_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c390_l450_action_invoke"); - let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(18446744073709551615))]); + let result = instance.call( + "i64.reinterpret_f64", + &[Value::F64(f64::from_bits(18446744073709551615))], + ); assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); result.map(|_| ()) } @@ -3876,7 +4450,10 @@ fn c397_l457_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 458 fn c398_l458_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c398_l458_action_invoke"); - let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "i64.reinterpret_f64", + &[Value::F64(f64::from_bits(9221120237041090560))], + ); assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); result.map(|_| ()) } @@ -3884,7 +4461,10 @@ fn c398_l458_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 459 fn c399_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c399_l459_action_invoke"); - let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "i64.reinterpret_f64", + &[Value::F64(f64::from_bits(18444492273895866368))], + ); assert_eq!(result, Ok(Some(Value::I64(-2251799813685248 as i64)))); result.map(|_| ()) } @@ -3892,7 +4472,10 @@ fn c399_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 460 fn c400_l460_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c400_l460_action_invoke"); - let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "i64.reinterpret_f64", + &[Value::F64(f64::from_bits(9219994337134247936))], + ); assert_eq!(result, Ok(Some(Value::I64(9219994337134247936 as i64)))); result.map(|_| ()) } @@ -3900,7 +4483,10 @@ fn c400_l460_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 461 fn c401_l461_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c401_l461_action_invoke"); - let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "i64.reinterpret_f64", + &[Value::F64(f64::from_bits(18443366373989023744))], + ); assert_eq!(result, Ok(Some(Value::I64(-3377699720527872 as i64)))); result.map(|_| ()) } diff --git a/lib/runtime/tests/spectests/custom.rs b/lib/runtime/tests/spectests/custom.rs index c31fde37e..52aa9b461 100644 --- a/lib/runtime/tests/spectests/custom.rs +++ b/lib/runtime/tests/spectests/custom.rs @@ -5,26 +5,25 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { let module_str = "(module) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -44,8 +43,11 @@ fn create_module_2() -> Box { let module_str = "(module) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -71,8 +73,11 @@ fn create_module_3() -> Box { (export \"addTwo\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -85,7 +90,10 @@ fn start_module_3(instance: &mut Instance) { fn c3_l61_assert_malformed() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 69 @@ -93,7 +101,10 @@ fn c3_l61_assert_malformed() { fn c4_l69_assert_malformed() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 77 @@ -101,31 +112,59 @@ fn c4_l69_assert_malformed() { fn c5_l77_assert_malformed() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 0, 0, 0, 5, 1, 0, 7, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 85 #[test] fn c6_l85_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 0, 38, 16, 97, 32, 99, 117, 115, 116, 111, 109, 32, 115, 101, 99, 116, 105, 111, 110, 116, 104, 105, 115, 32, 105, 115, 32, 116, 104, 101, 32, 112, 97, 121, 108, 111, 97, 100]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 0, 38, 16, 97, 32, 99, 117, 115, 116, 111, 109, 32, 115, 101, + 99, 116, 105, 111, 110, 116, 104, 105, 115, 32, 105, 115, 32, 116, 104, 101, 32, 112, 97, + 121, 108, 111, 97, 100, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 93 #[test] fn c7_l93_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 0, 37, 16, 97, 32, 99, 117, 115, 116, 111, 109, 32, 115, 101, 99, 116, 105, 111, 110, 116, 104, 105, 115, 32, 105, 115, 32, 116, 104, 101, 32, 112, 97, 121, 108, 111, 97, 100, 0, 36, 16, 97, 32, 99, 117, 115, 116, 111, 109, 32, 115, 101, 99, 116, 105, 111, 110, 116, 104, 105, 115, 32, 105, 115, 32, 116, 104, 101, 32, 112, 97, 121, 108, 111, 97, 100]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 0, 37, 16, 97, 32, 99, 117, 115, 116, 111, 109, 32, 115, 101, + 99, 116, 105, 111, 110, 116, 104, 105, 115, 32, 105, 115, 32, 116, 104, 101, 32, 112, 97, + 121, 108, 111, 97, 100, 0, 36, 16, 97, 32, 99, 117, 115, 116, 111, 109, 32, 115, 101, 99, + 116, 105, 111, 110, 116, 104, 105, 115, 32, 105, 115, 32, 116, 104, 101, 32, 112, 97, 121, + 108, 111, 97, 100, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 102 #[test] fn c8_l102_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 7, 1, 96, 2, 127, 127, 1, 127, 0, 37, 16, 97, 32, 99, 117, 115, 116, 111, 109, 32, 115, 101, 99, 116, 105, 111, 110, 116, 104, 105, 115, 32, 105, 115, 32, 116, 104, 101, 32, 112, 97, 121, 108, 111, 97, 100, 3, 2, 1, 0, 10, 9, 1, 7, 0, 32, 0, 32, 1, 106, 11, 0, 27, 7, 99, 117, 115, 116, 111, 109, 50, 116, 104, 105, 115, 32, 105, 115, 32, 116, 104, 101, 32, 112, 97, 121, 108, 111, 97, 100]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 7, 1, 96, 2, 127, 127, 1, 127, 0, 37, 16, 97, 32, 99, 117, + 115, 116, 111, 109, 32, 115, 101, 99, 116, 105, 111, 110, 116, 104, 105, 115, 32, 105, 115, + 32, 116, 104, 101, 32, 112, 97, 121, 108, 111, 97, 100, 3, 2, 1, 0, 10, 9, 1, 7, 0, 32, 0, + 32, 1, 106, 11, 0, 27, 7, 99, 117, 115, 116, 111, 109, 50, 116, 104, 105, 115, 32, 105, + 115, 32, 116, 104, 101, 32, 112, 97, 121, 108, 111, 97, 100, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 115 @@ -133,7 +172,10 @@ fn c8_l102_assert_malformed() { fn c9_l115_assert_malformed() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 0, 97, 115, 109, 1, 0, 0, 0]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } #[test] diff --git a/lib/runtime/tests/spectests/data.rs b/lib/runtime/tests/spectests/data.rs index bf2c7efdb..59702266c 100644 --- a/lib/runtime/tests/spectests/data.rs +++ b/lib/runtime/tests/spectests/data.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 5 fn create_module_1() -> Box { @@ -36,8 +32,11 @@ fn create_module_1() -> Box { (data (;11;) (i32.const 0) \"abc\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -59,8 +58,11 @@ fn create_module_2() -> Box { (data (;0;) (i32.const 0) \"a\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -82,8 +84,11 @@ fn create_module_3() -> Box { (data (;0;) (i32.const 0) \"a\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -109,8 +114,11 @@ fn create_module_4() -> Box { (data (;4;) (i32.const 3) \"c\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { @@ -137,8 +145,11 @@ fn create_module_5() -> Box { (data (;5;) (i32.const 1) \"h\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_5(instance: &mut Instance) { @@ -161,8 +172,11 @@ fn create_module_6() -> Box { (data (;1;) (i32.const 65535) \"b\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_6(instance: &mut Instance) { @@ -185,8 +199,11 @@ fn create_module_7() -> Box { (data (;1;) (i32.const 65535) \"b\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_7(instance: &mut Instance) { @@ -208,8 +225,11 @@ fn create_module_8() -> Box { (data (;0;) (i32.const 131071) \"a\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_8(instance: &mut Instance) { @@ -231,8 +251,11 @@ fn create_module_9() -> Box { (data (;0;) (i32.const 0) \"\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_9(instance: &mut Instance) { @@ -254,8 +277,11 @@ fn create_module_10() -> Box { (data (;0;) (i32.const 0) \"\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_10(instance: &mut Instance) { @@ -277,8 +303,11 @@ fn create_module_11() -> Box { (data (;0;) (i32.const 0) \"\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_11(instance: &mut Instance) { @@ -300,8 +329,11 @@ fn create_module_12() -> Box { (data (;0;) (i32.const 65536) \"\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_12(instance: &mut Instance) { @@ -323,8 +355,11 @@ fn create_module_13() -> Box { (data (;0;) (i32.const 0) \"\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_13(instance: &mut Instance) { @@ -346,8 +381,11 @@ fn create_module_14() -> Box { (data (;0;) (i32.const 0) \"\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_14(instance: &mut Instance) { @@ -369,8 +407,11 @@ fn create_module_15() -> Box { (data (;0;) (i32.const 0) \"\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_15(instance: &mut Instance) { @@ -392,8 +433,11 @@ fn create_module_16() -> Box { (data (;0;) (i32.const 0) \"a\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_16(instance: &mut Instance) { @@ -415,8 +459,11 @@ fn create_module_17() -> Box { (data (;0;) (i32.const 0) \"a\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_17(instance: &mut Instance) { @@ -438,8 +485,11 @@ fn create_module_18() -> Box { (data (;0;) (i32.const 1) \"a\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_18(instance: &mut Instance) { @@ -461,8 +511,11 @@ fn create_module_19() -> Box { (data (;0;) (i32.const 1) \"a\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_19(instance: &mut Instance) { @@ -509,7 +562,9 @@ fn c33_l289_assert_invalid() { // Line 298 #[test] fn c34_l298_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 6, 1, 0, 66, 0, 11, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 6, 1, 0, 66, 0, 11, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -517,7 +572,9 @@ fn c34_l298_assert_invalid() { // Line 306 #[test] fn c35_l306_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 7, 1, 0, 65, 0, 104, 11, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 7, 1, 0, 65, 0, 104, 11, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -525,7 +582,9 @@ fn c35_l306_assert_invalid() { // Line 314 #[test] fn c36_l314_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 5, 1, 0, 1, 11, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 5, 1, 0, 1, 11, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -533,7 +592,9 @@ fn c36_l314_assert_invalid() { // Line 322 #[test] fn c37_l322_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 7, 1, 0, 1, 65, 0, 11, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 7, 1, 0, 1, 65, 0, 11, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -541,7 +602,9 @@ fn c37_l322_assert_invalid() { // Line 330 #[test] fn c38_l330_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 7, 1, 0, 65, 0, 1, 11, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 7, 1, 0, 65, 0, 1, 11, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/elem.rs b/lib/runtime/tests/spectests/elem.rs index 68bf9ef0c..ac9236c97 100644 --- a/lib/runtime/tests/spectests/elem.rs +++ b/lib/runtime/tests/spectests/elem.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 4 fn create_module_1() -> Box { @@ -38,8 +34,11 @@ fn create_module_1() -> Box { (elem (;11;) (i32.const 0) 0 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -63,8 +62,11 @@ fn create_module_2() -> Box { (elem (;0;) (i32.const 0) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -88,8 +90,11 @@ fn create_module_3() -> Box { (elem (;0;) (i32.const 0) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -117,8 +122,11 @@ fn create_module_4() -> Box { (elem (;4;) (i32.const 3) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { @@ -146,8 +154,11 @@ fn create_module_5() -> Box { (elem (;4;) (i32.const 5) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_5(instance: &mut Instance) { @@ -172,8 +183,11 @@ fn create_module_6() -> Box { (elem (;0;) (i32.const 0) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_6(instance: &mut Instance) { @@ -198,8 +212,11 @@ fn create_module_7() -> Box { (elem (;0;) (get_global 0) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_7(instance: &mut Instance) { @@ -235,8 +252,11 @@ fn create_module_8() -> Box { (elem (;1;) (i32.const 9) 1)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_8(instance: &mut Instance) { @@ -278,8 +298,11 @@ fn create_module_9() -> Box { (elem (;0;) (i32.const 9) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_9(instance: &mut Instance) { @@ -303,8 +326,11 @@ fn create_module_10() -> Box { (elem (;0;) (i32.const 9) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_10(instance: &mut Instance) { @@ -326,8 +352,11 @@ fn create_module_11() -> Box { (elem (;0;) (i32.const 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_11(instance: &mut Instance) { @@ -349,8 +378,11 @@ fn create_module_12() -> Box { (elem (;0;) (i32.const 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_12(instance: &mut Instance) { @@ -372,8 +404,11 @@ fn create_module_13() -> Box { (elem (;0;) (i32.const 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_13(instance: &mut Instance) { @@ -395,8 +430,11 @@ fn create_module_14() -> Box { (elem (;0;) (i32.const 20))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_14(instance: &mut Instance) { @@ -420,8 +458,11 @@ fn create_module_15() -> Box { (elem (;0;) (i32.const 0) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_15(instance: &mut Instance) { @@ -445,8 +486,11 @@ fn create_module_16() -> Box { (elem (;0;) (i32.const 0) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_16(instance: &mut Instance) { @@ -470,8 +514,11 @@ fn create_module_17() -> Box { (elem (;0;) (i32.const 1) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_17(instance: &mut Instance) { @@ -495,8 +542,11 @@ fn create_module_18() -> Box { (elem (;0;) (i32.const 1) 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_18(instance: &mut Instance) { @@ -531,7 +581,10 @@ fn start_module_18(instance: &mut Instance) { // Line 248 #[test] fn c32_l248_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 9, 7, 1, 0, 65, 0, 11, 1, 0, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 9, 7, 1, 0, 65, 0, 11, 1, 0, + 10, 4, 1, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -539,7 +592,9 @@ fn c32_l248_assert_invalid() { // Line 258 #[test] fn c33_l258_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 6, 1, 0, 66, 0, 11, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 6, 1, 0, 66, 0, 11, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -547,7 +602,9 @@ fn c33_l258_assert_invalid() { // Line 266 #[test] fn c34_l266_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 7, 1, 0, 65, 0, 104, 11, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 7, 1, 0, 65, 0, 104, 11, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -555,7 +612,9 @@ fn c34_l266_assert_invalid() { // Line 274 #[test] fn c35_l274_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 5, 1, 0, 1, 11, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 5, 1, 0, 1, 11, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -563,7 +622,9 @@ fn c35_l274_assert_invalid() { // Line 282 #[test] fn c36_l282_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 7, 1, 0, 1, 65, 0, 11, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 7, 1, 0, 1, 65, 0, 11, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -571,7 +632,9 @@ fn c36_l282_assert_invalid() { // Line 290 #[test] fn c37_l290_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 7, 1, 0, 65, 0, 1, 11, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 7, 1, 0, 65, 0, 1, 11, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -600,8 +663,11 @@ fn create_module_19() -> Box { (elem (;1;) (i32.const 9) 1)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_19(instance: &mut Instance) { @@ -642,8 +708,11 @@ fn create_module_20() -> Box { (elem (;1;) (i32.const 9) 1)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_20(instance: &mut Instance) { @@ -693,8 +762,11 @@ fn create_module_21() -> Box { (elem (;1;) (i32.const 9) 1)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_21(instance: &mut Instance) { @@ -708,14 +780,14 @@ fn start_module_21(instance: &mut Instance) { fn c44_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c44_l353_action_invoke"); let result = instance.call("call-7", &[]); - + result.map(|_| ()) } #[test] fn c44_l353_assert_trap() { let mut instance = create_module_21(); - let result = c44_l353_action_invoke(&mut*instance); + let result = c44_l353_action_invoke(&mut *instance); assert!(result.is_err()); } diff --git a/lib/runtime/tests/spectests/endianness.rs b/lib/runtime/tests/spectests/endianness.rs index 9f9de5c5c..4deb926c8 100644 --- a/lib/runtime/tests/spectests/endianness.rs +++ b/lib/runtime/tests/spectests/endianness.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { @@ -227,8 +223,11 @@ fn create_module_1() -> Box { (export \"f64_store\" (func 22))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -519,8 +518,16 @@ fn c35_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 176 fn c36_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c36_l176_action_invoke"); - let result = instance.call("f32_load", &[Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32_load", + &[Value::F32((340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -743,8 +750,16 @@ fn c63_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 212 fn c64_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c64_l212_action_invoke"); - let result = instance.call("f32_store", &[Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32_store", + &[Value::F32((340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } diff --git a/lib/runtime/tests/spectests/exports.rs b/lib/runtime/tests/spectests/exports.rs index 76452cb2d..e1cbd1e1a 100644 --- a/lib/runtime/tests/spectests/exports.rs +++ b/lib/runtime/tests/spectests/exports.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -26,8 +22,11 @@ fn create_module_1() -> Box { (export \"a\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -51,8 +50,11 @@ fn create_module_2() -> Box { (export \"b\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -77,8 +79,11 @@ fn create_module_3() -> Box { (export \"b\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -101,8 +106,11 @@ fn create_module_4() -> Box { (export \"a\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { @@ -127,8 +135,11 @@ fn create_module_5() -> Box { (export \"c\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_5(instance: &mut Instance) { @@ -152,8 +163,11 @@ fn create_module_6() -> Box { (export \"b\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_6(instance: &mut Instance) { @@ -176,8 +190,11 @@ fn create_module_7() -> Box { (export \"a\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_7(instance: &mut Instance) { @@ -200,8 +217,11 @@ fn create_module_8() -> Box { (export \"a\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_8(instance: &mut Instance) { @@ -224,8 +244,11 @@ fn create_module_9() -> Box { (export \"a\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_9(instance: &mut Instance) { @@ -248,8 +271,11 @@ fn create_module_10() -> Box { (export \"a\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_10(instance: &mut Instance) { @@ -272,8 +298,11 @@ fn create_module_11() -> Box { (export \"a\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_11(instance: &mut Instance) { @@ -300,8 +329,11 @@ fn create_module_12() -> Box { (export \"e\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_12(instance: &mut Instance) { @@ -328,7 +360,10 @@ fn c13_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 29 #[test] fn c14_l29_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 7, 5, 1, 1, 97, 0, 1, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 7, 5, 1, 1, 97, 0, 1, 10, 4, 1, + 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -336,7 +371,10 @@ fn c14_l29_assert_invalid() { // Line 33 #[test] fn c15_l33_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 0, + 0, 10, 4, 1, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -344,7 +382,10 @@ fn c15_l33_assert_invalid() { // Line 37 #[test] fn c16_l37_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 0, 1, 10, 7, 2, 2, 0, 11, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, + 0, 1, 10, 7, 2, 2, 0, 11, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -352,7 +393,10 @@ fn c16_l37_assert_invalid() { // Line 41 #[test] fn c17_l41_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 0, 0, 1, 97, 3, 0, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, + 9, 2, 1, 97, 0, 0, 1, 97, 3, 0, 10, 4, 1, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -360,7 +404,10 @@ fn c17_l41_assert_invalid() { // Line 45 #[test] fn c18_l45_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 1, 0, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, + 97, 0, 0, 1, 97, 1, 0, 10, 4, 1, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -368,7 +415,10 @@ fn c18_l45_assert_invalid() { // Line 49 #[test] fn c19_l49_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 2, 0, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, + 0, 0, 1, 97, 2, 0, 10, 4, 1, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -389,8 +439,11 @@ fn create_module_13() -> Box { (export \"a\" (global 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_13(instance: &mut Instance) { @@ -413,8 +466,11 @@ fn create_module_14() -> Box { (export \"b\" (global 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_14(instance: &mut Instance) { @@ -438,8 +494,11 @@ fn create_module_15() -> Box { (export \"b\" (global 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_15(instance: &mut Instance) { @@ -461,8 +520,11 @@ fn create_module_16() -> Box { (export \"a\" (global 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_16(instance: &mut Instance) { @@ -484,8 +546,11 @@ fn create_module_17() -> Box { (export \"a\" (global 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_17(instance: &mut Instance) { @@ -507,8 +572,11 @@ fn create_module_18() -> Box { (export \"a\" (global 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_18(instance: &mut Instance) { @@ -530,8 +598,11 @@ fn create_module_19() -> Box { (export \"a\" (global 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_19(instance: &mut Instance) { @@ -553,8 +624,11 @@ fn create_module_20() -> Box { (export \"a\" (global 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_20(instance: &mut Instance) { @@ -576,8 +650,11 @@ fn create_module_21() -> Box { (export \"a\" (global 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_21(instance: &mut Instance) { @@ -599,8 +676,11 @@ fn create_module_22() -> Box { (export \"e\" (global 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_22(instance: &mut Instance) { @@ -615,7 +695,9 @@ fn start_module_22(instance: &mut Instance) { // Line 78 #[test] fn c32_l78_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 5, 1, 1, 97, 3, 1]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 5, 1, 1, 97, 3, 1, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -623,7 +705,9 @@ fn c32_l78_assert_invalid() { // Line 82 #[test] fn c33_l82_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 3, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 3, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -631,7 +715,10 @@ fn c33_l82_assert_invalid() { // Line 86 #[test] fn c34_l86_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 2, 127, 0, 65, 0, 11, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 3, 1]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 2, 127, 0, 65, 0, 11, 127, 0, 65, 0, 11, 7, 9, 2, 1, + 97, 3, 0, 1, 97, 3, 1, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -639,7 +726,10 @@ fn c34_l86_assert_invalid() { // Line 90 #[test] fn c35_l90_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, + 9, 2, 1, 97, 3, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -647,7 +737,10 @@ fn c35_l90_assert_invalid() { // Line 94 #[test] fn c36_l94_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 1, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, + 97, 3, 0, 1, 97, 1, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -655,7 +748,10 @@ fn c36_l94_assert_invalid() { // Line 98 #[test] fn c37_l98_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 2, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, + 0, 1, 97, 2, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -674,8 +770,11 @@ fn create_module_23() -> Box { (export \"a\" (table 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_23(instance: &mut Instance) { @@ -698,8 +797,11 @@ fn create_module_24() -> Box { (export \"b\" (table 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_24(instance: &mut Instance) { @@ -721,8 +823,11 @@ fn create_module_25() -> Box { (export \"a\" (table 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_25(instance: &mut Instance) { @@ -744,8 +849,11 @@ fn create_module_26() -> Box { (export \"a\" (table 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_26(instance: &mut Instance) { @@ -767,8 +875,11 @@ fn create_module_27() -> Box { (export \"a\" (table 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_27(instance: &mut Instance) { @@ -790,8 +901,11 @@ fn create_module_28() -> Box { (export \"a\" (table 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_28(instance: &mut Instance) { @@ -813,8 +927,11 @@ fn create_module_29() -> Box { (export \"a\" (table 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_29(instance: &mut Instance) { @@ -836,8 +953,11 @@ fn create_module_30() -> Box { (export \"a\" (table 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_30(instance: &mut Instance) { @@ -859,8 +979,11 @@ fn create_module_31() -> Box { (export \"a\" (table 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_31(instance: &mut Instance) { @@ -882,8 +1005,11 @@ fn create_module_32() -> Box { (export \"a\" (table 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_32(instance: &mut Instance) { @@ -905,8 +1031,11 @@ fn create_module_33() -> Box { (export \"a\" (table 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_33(instance: &mut Instance) { @@ -928,8 +1057,11 @@ fn create_module_34() -> Box { (export \"a\" (table 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_34(instance: &mut Instance) { @@ -951,8 +1083,11 @@ fn create_module_35() -> Box { (export \"a\" (table 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_35(instance: &mut Instance) { @@ -974,8 +1109,11 @@ fn create_module_36() -> Box { (export \"a\" (table 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_36(instance: &mut Instance) { @@ -986,7 +1124,9 @@ fn start_module_36(instance: &mut Instance) { // Line 126 #[test] fn c52_l126_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 7, 5, 1, 1, 97, 1, 1]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 7, 5, 1, 1, 97, 1, 1, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -994,7 +1134,9 @@ fn c52_l126_assert_invalid() { // Line 130 #[test] fn c53_l130_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, 97, 1, 0, 1, 97, 1, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, 97, 1, 0, 1, 97, 1, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1002,7 +1144,10 @@ fn c53_l130_assert_invalid() { // Line 139 #[test] fn c54_l139_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, 97, 1, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, + 97, 1, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1010,7 +1155,10 @@ fn c54_l139_assert_invalid() { // Line 143 #[test] fn c55_l143_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 1, 0, 1, 97, 3, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, + 97, 1, 0, 1, 97, 3, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1018,7 +1166,10 @@ fn c55_l143_assert_invalid() { // Line 147 #[test] fn c56_l147_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 1, 0, 1, 97, 2, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 1, 0, 1, + 97, 2, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1037,8 +1188,11 @@ fn create_module_37() -> Box { (export \"a\" (memory 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_37(instance: &mut Instance) { @@ -1061,8 +1215,11 @@ fn create_module_38() -> Box { (export \"b\" (memory 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_38(instance: &mut Instance) { @@ -1084,8 +1241,11 @@ fn create_module_39() -> Box { (export \"a\" (memory 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_39(instance: &mut Instance) { @@ -1107,8 +1267,11 @@ fn create_module_40() -> Box { (export \"a\" (memory 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_40(instance: &mut Instance) { @@ -1130,8 +1293,11 @@ fn create_module_41() -> Box { (export \"a\" (memory 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_41(instance: &mut Instance) { @@ -1153,8 +1319,11 @@ fn create_module_42() -> Box { (export \"a\" (memory 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_42(instance: &mut Instance) { @@ -1176,8 +1345,11 @@ fn create_module_43() -> Box { (export \"a\" (memory 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_43(instance: &mut Instance) { @@ -1199,8 +1371,11 @@ fn create_module_44() -> Box { (export \"a\" (memory 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_44(instance: &mut Instance) { @@ -1222,8 +1397,11 @@ fn create_module_45() -> Box { (export \"a\" (memory 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_45(instance: &mut Instance) { @@ -1245,8 +1423,11 @@ fn create_module_46() -> Box { (export \"a\" (memory 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_46(instance: &mut Instance) { @@ -1268,8 +1449,11 @@ fn create_module_47() -> Box { (export \"a\" (memory 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_47(instance: &mut Instance) { @@ -1291,8 +1475,11 @@ fn create_module_48() -> Box { (export \"a\" (memory 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_48(instance: &mut Instance) { @@ -1314,8 +1501,11 @@ fn create_module_49() -> Box { (export \"a\" (memory 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_49(instance: &mut Instance) { @@ -1337,8 +1527,11 @@ fn create_module_50() -> Box { (export \"a\" (memory 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_50(instance: &mut Instance) { @@ -1349,7 +1542,9 @@ fn start_module_50(instance: &mut Instance) { // Line 175 #[test] fn c71_l175_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 7, 5, 1, 1, 97, 2, 1]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 7, 5, 1, 1, 97, 2, 1, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1357,7 +1552,9 @@ fn c71_l175_assert_invalid() { // Line 179 #[test] fn c72_l179_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 2, 0, 1, 97, 2, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 2, 0, 1, 97, 2, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1365,7 +1562,10 @@ fn c72_l179_assert_invalid() { // Line 188 #[test] fn c73_l188_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 2, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, + 2, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1373,7 +1573,10 @@ fn c73_l188_assert_invalid() { // Line 192 #[test] fn c74_l192_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 2, 0, 1, 97, 3, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 2, + 0, 1, 97, 3, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1381,7 +1584,10 @@ fn c74_l192_assert_invalid() { // Line 196 #[test] fn c75_l196_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 2, 0, 1, 97, 1, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 2, 0, 1, + 97, 1, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/f32_.rs b/lib/runtime/tests/spectests/f32_.rs index eaad87031..acc61084d 100644 --- a/lib/runtime/tests/spectests/f32_.rs +++ b/lib/runtime/tests/spectests/f32_.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 5 fn create_module_1() -> Box { @@ -75,8 +71,11 @@ fn create_module_1() -> Box { (export \"nearest\" (func 10))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -119,64 +118,152 @@ fn c4_l22_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 23 fn c5_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c5_l23_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 24 fn c6_l24_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c6_l24_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 25 fn c7_l25_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c7_l25_action_invoke"); - let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 26 fn c8_l26_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c8_l26_action_invoke"); - let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 27 fn c9_l27_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c9_l27_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 28 fn c10_l28_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c10_l28_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 29 fn c11_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c11_l29_action_invoke"); - let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 30 fn c12_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c12_l30_action_invoke"); - let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } @@ -279,39 +366,86 @@ fn c24_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 43 fn c25_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c25_l43_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 44 fn c26_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c26_l44_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 45 fn c27_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c27_l45_action_invoke"); - let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 46 fn c28_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c28_l46_action_invoke"); - let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 47 fn c29_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c29_l47_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -327,7 +461,10 @@ fn c30_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 49 fn c31_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c31_l49_action_invoke"); - let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -342,136 +479,281 @@ fn c32_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 51 fn c33_l51_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c33_l51_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c33_l51_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c33_l51_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c33_l51_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 52 fn c34_l52_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c34_l52_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c34_l52_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c34_l52_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c34_l52_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 53 fn c35_l53_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c35_l53_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c35_l53_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c35_l53_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c35_l53_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 54 fn c36_l54_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c36_l54_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c36_l54_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c36_l54_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c36_l54_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 55 fn c37_l55_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c37_l55_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c37_l55_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c37_l55_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c37_l55_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 56 fn c38_l56_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c38_l56_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c38_l56_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c38_l56_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c38_l56_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 57 fn c39_l57_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c39_l57_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c39_l57_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c39_l57_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c39_l57_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 58 fn c40_l58_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c40_l58_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c40_l58_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c40_l58_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c40_l58_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 59 fn c41_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c41_l59_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 60 fn c42_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c42_l60_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 61 fn c43_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c43_l61_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 62 fn c44_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c44_l62_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 63 fn c45_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c45_l63_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000003f32) + ))) + ); result.map(|_| ()) } // Line 64 fn c46_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c46_l64_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -479,7 +761,13 @@ fn c46_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 65 fn c47_l65_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c47_l65_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -487,47 +775,108 @@ fn c47_l65_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 66 fn c48_l66_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c48_l66_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000003f32) + ))) + ); result.map(|_| ()) } // Line 67 fn c49_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c49_l67_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754945f32) + ))) + ); result.map(|_| ()) } // Line 68 fn c50_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c50_l68_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754942f32) + ))) + ); result.map(|_| ()) } // Line 69 fn c51_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c51_l69_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754942f32) + ))) + ); result.map(|_| ()) } // Line 70 fn c52_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c52_l70_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754945f32) + ))) + ); result.map(|_| ()) } // Line 71 fn c53_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c53_l71_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -535,7 +884,13 @@ fn c53_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 72 fn c54_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c54_l72_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -543,7 +898,13 @@ fn c54_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 73 fn c55_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c55_l73_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -551,7 +912,13 @@ fn c55_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 74 fn c56_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c56_l74_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -559,7 +926,13 @@ fn c56_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 75 fn c57_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c57_l75_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -567,7 +940,13 @@ fn c57_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 76 fn c58_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c58_l76_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -575,7 +954,13 @@ fn c58_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 77 fn c59_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c59_l77_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -583,7 +968,13 @@ fn c59_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 78 fn c60_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c60_l78_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -591,7 +982,13 @@ fn c60_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 79 fn c61_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c61_l79_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -599,7 +996,13 @@ fn c61_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 80 fn c62_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c62_l80_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -607,7 +1010,13 @@ fn c62_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 81 fn c63_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c63_l81_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -615,7 +1024,13 @@ fn c63_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 82 fn c64_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c64_l82_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -623,39 +1038,89 @@ fn c64_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 83 fn c65_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c65_l83_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 84 fn c66_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c66_l84_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 85 fn c67_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c67_l85_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 86 fn c68_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c68_l86_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 87 fn c69_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c69_l87_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -663,7 +1128,13 @@ fn c69_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 88 fn c70_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c70_l88_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -671,7 +1142,13 @@ fn c70_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 89 fn c71_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c71_l89_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -679,175 +1156,382 @@ fn c71_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 90 fn c72_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c72_l90_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 91 fn c73_l91_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c73_l91_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c73_l91_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c73_l91_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c73_l91_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 92 fn c74_l92_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c74_l92_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c74_l92_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c74_l92_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c74_l92_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 93 fn c75_l93_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c75_l93_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c75_l93_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c75_l93_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c75_l93_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 94 fn c76_l94_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c76_l94_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c76_l94_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c76_l94_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c76_l94_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 95 fn c77_l95_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c77_l95_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c77_l95_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c77_l95_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c77_l95_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 96 fn c78_l96_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c78_l96_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c78_l96_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c78_l96_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c78_l96_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 97 fn c79_l97_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c79_l97_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c79_l97_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c79_l97_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c79_l97_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 98 fn c80_l98_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c80_l98_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c80_l98_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c80_l98_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c80_l98_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 99 fn c81_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c81_l99_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 100 fn c82_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c82_l100_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 101 fn c83_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c83_l101_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 102 fn c84_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c84_l102_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 103 fn c85_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c85_l103_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754945f32) + ))) + ); result.map(|_| ()) } // Line 104 fn c86_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c86_l104_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754942f32) + ))) + ); result.map(|_| ()) } // Line 105 fn c87_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c87_l105_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754942f32) + ))) + ); result.map(|_| ()) } // Line 106 fn c88_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c88_l106_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754945f32) + ))) + ); result.map(|_| ()) } // Line 107 fn c89_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c89_l107_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000023509887f32) + ))) + ); result.map(|_| ()) } // Line 108 fn c90_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c90_l108_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -855,7 +1539,13 @@ fn c90_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 109 fn c91_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c91_l109_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -863,15 +1553,32 @@ fn c91_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 110 fn c92_l110_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c92_l110_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000023509887f32) + ))) + ); result.map(|_| ()) } // Line 111 fn c93_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c93_l111_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -879,7 +1586,13 @@ fn c93_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 112 fn c94_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c94_l112_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -887,7 +1600,13 @@ fn c94_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 113 fn c95_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c95_l113_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -895,7 +1614,13 @@ fn c95_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 114 fn c96_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c96_l114_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -903,7 +1628,13 @@ fn c96_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 115 fn c97_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c97_l115_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -911,7 +1642,13 @@ fn c97_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 116 fn c98_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c98_l116_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -919,7 +1656,13 @@ fn c98_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 117 fn c99_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c99_l117_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -927,7 +1670,13 @@ fn c99_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 118 fn c100_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c100_l118_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -935,7 +1684,13 @@ fn c100_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 119 fn c101_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c101_l119_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -943,7 +1698,13 @@ fn c101_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 120 fn c102_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c102_l120_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -951,7 +1712,13 @@ fn c102_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 121 fn c103_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c103_l121_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -959,7 +1726,13 @@ fn c103_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 122 fn c104_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c104_l122_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -967,39 +1740,89 @@ fn c104_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 123 fn c105_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c105_l123_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 124 fn c106_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c106_l124_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 125 fn c107_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c107_l125_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 126 fn c108_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c108_l126_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 127 fn c109_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c109_l127_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -1007,7 +1830,13 @@ fn c109_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 128 fn c110_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c110_l128_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -1015,7 +1844,13 @@ fn c110_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 129 fn c111_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c111_l129_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -1023,96 +1858,198 @@ fn c111_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 130 fn c112_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c112_l130_action_invoke"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 131 fn c113_l131_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c113_l131_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c113_l131_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c113_l131_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c113_l131_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 132 fn c114_l132_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c114_l132_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c114_l132_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c114_l132_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c114_l132_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 133 fn c115_l133_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c115_l133_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c115_l133_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c115_l133_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c115_l133_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 134 fn c116_l134_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c116_l134_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c116_l134_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c116_l134_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c116_l134_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 135 fn c117_l135_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c117_l135_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c117_l135_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c117_l135_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c117_l135_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 136 fn c118_l136_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c118_l136_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c118_l136_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c118_l136_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c118_l136_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 137 fn c119_l137_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c119_l137_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c119_l137_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c119_l137_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c119_l137_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 138 fn c120_l138_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c120_l138_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c120_l138_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c120_l138_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c120_l138_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -1151,7 +2088,13 @@ fn c124_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 143 fn c125_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c125_l143_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -1159,7 +2102,13 @@ fn c125_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 144 fn c126_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c126_l144_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -1167,7 +2116,13 @@ fn c126_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 145 fn c127_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c127_l145_action_invoke"); - let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -1175,7 +2130,13 @@ fn c127_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 146 fn c128_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c128_l146_action_invoke"); - let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -1183,7 +2144,13 @@ fn c128_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 147 fn c129_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c129_l147_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -1191,7 +2158,13 @@ fn c129_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 148 fn c130_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c130_l148_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -1199,7 +2172,13 @@ fn c130_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 149 fn c131_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c131_l149_action_invoke"); - let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -1207,7 +2186,13 @@ fn c131_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 150 fn c132_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c132_l150_action_invoke"); - let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -1311,39 +2296,86 @@ fn c144_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 163 fn c145_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c145_l163_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 164 fn c146_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c146_l164_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 165 fn c147_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c147_l165_action_invoke"); - let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 166 fn c148_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c148_l166_action_invoke"); - let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 167 fn c149_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c149_l167_action_invoke"); - let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -1359,7 +2391,10 @@ fn c150_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 169 fn c151_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c151_l169_action_invoke"); - let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -1374,89 +2409,173 @@ fn c152_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 171 fn c153_l171_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c153_l171_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c153_l171_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c153_l171_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c153_l171_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 172 fn c154_l172_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c154_l172_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c154_l172_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c154_l172_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c154_l172_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 173 fn c155_l173_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c155_l173_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c155_l173_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c155_l173_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c155_l173_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 174 fn c156_l174_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c156_l174_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c156_l174_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c156_l174_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c156_l174_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 175 fn c157_l175_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c157_l175_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c157_l175_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c157_l175_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c157_l175_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 176 fn c158_l176_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c158_l176_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c158_l176_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c158_l176_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c158_l176_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 177 fn c159_l177_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c159_l177_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c159_l177_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c159_l177_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c159_l177_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 178 fn c160_l178_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c160_l178_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c160_l178_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c160_l178_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c160_l178_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -1495,7 +2614,13 @@ fn c164_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 183 fn c165_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c165_l183_action_invoke"); - let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1503,7 +2628,13 @@ fn c165_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 184 fn c166_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c166_l184_action_invoke"); - let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1511,7 +2642,13 @@ fn c166_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 185 fn c167_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c167_l185_action_invoke"); - let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1519,7 +2656,13 @@ fn c167_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 186 fn c168_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c168_l186_action_invoke"); - let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1527,7 +2670,13 @@ fn c168_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 187 fn c169_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c169_l187_action_invoke"); - let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1535,7 +2684,13 @@ fn c169_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 188 fn c170_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c170_l188_action_invoke"); - let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1543,7 +2698,13 @@ fn c170_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 189 fn c171_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c171_l189_action_invoke"); - let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1551,7 +2712,13 @@ fn c171_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 190 fn c172_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c172_l190_action_invoke"); - let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1655,39 +2822,86 @@ fn c184_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 203 fn c185_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c185_l203_action_invoke"); - let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 204 fn c186_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c186_l204_action_invoke"); - let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 205 fn c187_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c187_l205_action_invoke"); - let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 206 fn c188_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c188_l206_action_invoke"); - let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 207 fn c189_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c189_l207_action_invoke"); - let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -1703,7 +2917,10 @@ fn c190_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 209 fn c191_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c191_l209_action_invoke"); - let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -1718,89 +2935,173 @@ fn c192_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 211 fn c193_l211_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c193_l211_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c193_l211_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c193_l211_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c193_l211_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 212 fn c194_l212_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c194_l212_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c194_l212_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c194_l212_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c194_l212_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 213 fn c195_l213_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c195_l213_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c195_l213_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c195_l213_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c195_l213_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 214 fn c196_l214_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c196_l214_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c196_l214_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c196_l214_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c196_l214_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 215 fn c197_l215_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c197_l215_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c197_l215_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c197_l215_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c197_l215_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 216 fn c198_l216_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c198_l216_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c198_l216_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c198_l216_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c198_l216_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 217 fn c199_l217_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c199_l217_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c199_l217_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c199_l217_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c199_l217_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 218 fn c200_l218_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c200_l218_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c200_l218_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c200_l218_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c200_l218_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -1839,7 +3140,13 @@ fn c204_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 223 fn c205_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c205_l223_action_invoke"); - let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1847,7 +3154,13 @@ fn c205_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 224 fn c206_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c206_l224_action_invoke"); - let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1855,7 +3168,13 @@ fn c206_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 225 fn c207_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c207_l225_action_invoke"); - let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1863,7 +3182,13 @@ fn c207_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 226 fn c208_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c208_l226_action_invoke"); - let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1871,7 +3196,13 @@ fn c208_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 227 fn c209_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c209_l227_action_invoke"); - let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1879,7 +3210,13 @@ fn c209_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 228 fn c210_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c210_l228_action_invoke"); - let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1887,7 +3224,13 @@ fn c210_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 229 fn c211_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c211_l229_action_invoke"); - let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1895,7 +3238,13 @@ fn c211_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 230 fn c212_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c212_l230_action_invoke"); - let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1967,7 +3316,10 @@ fn c220_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 239 fn c221_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c221_l239_action_invoke"); - let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "add", + &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-12.566371f32))))); result.map(|_| ()) } @@ -1975,7 +3327,10 @@ fn c221_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 240 fn c222_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c222_l240_action_invoke"); - let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "add", + &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -1983,7 +3338,10 @@ fn c222_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 241 fn c223_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c223_l241_action_invoke"); - let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "add", + &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -1991,7 +3349,10 @@ fn c223_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 242 fn c224_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c224_l242_action_invoke"); - let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "add", + &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((12.566371f32))))); result.map(|_| ()) } @@ -1999,39 +3360,86 @@ fn c224_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 243 fn c225_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c225_l243_action_invoke"); - let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 244 fn c226_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c226_l244_action_invoke"); - let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 245 fn c227_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c227_l245_action_invoke"); - let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 246 fn c228_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c228_l246_action_invoke"); - let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 247 fn c229_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c229_l247_action_invoke"); - let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2039,7 +3447,10 @@ fn c229_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 248 fn c230_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c230_l248_action_invoke"); - let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "add", + &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2047,7 +3458,10 @@ fn c230_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 249 fn c231_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c231_l249_action_invoke"); - let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2055,295 +3469,664 @@ fn c231_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 250 fn c232_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c232_l250_action_invoke"); - let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "add", + &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 251 fn c233_l251_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c233_l251_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c233_l251_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c233_l251_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c233_l251_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 252 fn c234_l252_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c234_l252_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c234_l252_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c234_l252_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c234_l252_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 253 fn c235_l253_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c235_l253_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c235_l253_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c235_l253_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c235_l253_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 254 fn c236_l254_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c236_l254_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c236_l254_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c236_l254_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c236_l254_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 255 fn c237_l255_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c237_l255_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c237_l255_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c237_l255_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c237_l255_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 256 fn c238_l256_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c238_l256_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c238_l256_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c238_l256_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c238_l256_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 257 fn c239_l257_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c239_l257_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c239_l257_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c239_l257_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c239_l257_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 258 fn c240_l258_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c240_l258_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c240_l258_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c240_l258_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c240_l258_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 259 fn c241_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c241_l259_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 260 fn c242_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c242_l260_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 261 fn c243_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c243_l261_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 262 fn c244_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c244_l262_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 263 fn c245_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c245_l263_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 264 fn c246_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c246_l264_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 265 fn c247_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c247_l265_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 266 fn c248_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c248_l266_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 267 fn c249_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c249_l267_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 268 fn c250_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c250_l268_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 269 fn c251_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c251_l269_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 270 fn c252_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c252_l270_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 271 fn c253_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c253_l271_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 272 fn c254_l272_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c254_l272_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 273 fn c255_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c255_l273_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 274 fn c256_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c256_l274_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 275 fn c257_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c257_l275_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 276 fn c258_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c258_l276_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 277 fn c259_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c259_l277_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 278 fn c260_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c260_l278_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 279 fn c261_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c261_l279_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 280 fn c262_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c262_l280_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 281 fn c263_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c263_l281_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 282 fn c264_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c264_l282_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 283 fn c265_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c265_l283_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2351,7 +4134,13 @@ fn c265_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 284 fn c266_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c266_l284_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -2359,7 +4148,13 @@ fn c266_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 285 fn c267_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c267_l285_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -2367,7 +4162,13 @@ fn c267_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 286 fn c268_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c268_l286_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2375,7 +4176,13 @@ fn c268_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 287 fn c269_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c269_l287_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2383,7 +4190,13 @@ fn c269_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 288 fn c270_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c270_l288_action_invoke"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2391,7 +4204,13 @@ fn c270_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 289 fn c271_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c271_l289_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2399,103 +4218,208 @@ fn c271_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 290 fn c272_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c272_l290_action_invoke"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 291 fn c273_l291_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c273_l291_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c273_l291_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c273_l291_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c273_l291_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 292 fn c274_l292_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c274_l292_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c274_l292_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c274_l292_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c274_l292_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 293 fn c275_l293_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c275_l293_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c275_l293_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c275_l293_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c275_l293_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 294 fn c276_l294_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c276_l294_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c276_l294_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c276_l294_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c276_l294_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 295 fn c277_l295_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c277_l295_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c277_l295_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c277_l295_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c277_l295_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 296 fn c278_l296_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c278_l296_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c278_l296_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c278_l296_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c278_l296_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 297 fn c279_l297_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c279_l297_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c279_l297_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c279_l297_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c279_l297_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 298 fn c280_l298_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c280_l298_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c280_l298_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c280_l298_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c280_l298_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 299 fn c281_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c281_l299_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]); + let result = instance.call( + "add", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2503,7 +4427,10 @@ fn c281_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 300 fn c282_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c282_l300_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))]); + let result = instance.call( + "add", + &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2527,7 +4454,13 @@ fn c284_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 303 fn c285_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c285_l303_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2535,7 +4468,13 @@ fn c285_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 304 fn c286_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c286_l304_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2543,7 +4482,13 @@ fn c286_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 305 fn c287_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c287_l305_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2551,7 +4496,13 @@ fn c287_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 306 fn c288_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c288_l306_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "add", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2559,7 +4510,13 @@ fn c288_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 307 fn c289_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c289_l307_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2567,7 +4524,13 @@ fn c289_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 308 fn c290_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c290_l308_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2575,7 +4538,13 @@ fn c290_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 309 fn c291_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c291_l309_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2583,7 +4552,13 @@ fn c291_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 310 fn c292_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c292_l310_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "add", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2591,7 +4566,10 @@ fn c292_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 311 fn c293_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c293_l311_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]); + let result = instance.call( + "add", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2599,7 +4577,10 @@ fn c293_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 312 fn c294_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c294_l312_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))]); + let result = instance.call( + "add", + &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2623,7 +4604,10 @@ fn c296_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 315 fn c297_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c297_l315_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]); + let result = instance.call( + "add", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2631,7 +4615,10 @@ fn c297_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 316 fn c298_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c298_l316_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))]); + let result = instance.call( + "add", + &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2655,7 +4642,10 @@ fn c300_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 319 fn c301_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c301_l319_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "add", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2663,7 +4653,10 @@ fn c301_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 320 fn c302_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c302_l320_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "add", + &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2671,7 +4664,10 @@ fn c302_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 321 fn c303_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c303_l321_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "add", + &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2679,7 +4675,10 @@ fn c303_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 322 fn c304_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c304_l322_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "add", + &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2687,7 +4686,13 @@ fn c304_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 323 fn c305_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c305_l323_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2695,7 +4700,13 @@ fn c305_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 324 fn c306_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c306_l324_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2703,7 +4714,13 @@ fn c306_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 325 fn c307_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c307_l325_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32(f32::INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2711,7 +4728,13 @@ fn c307_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 326 fn c308_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c308_l326_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "add", + &[ + Value::F32(f32::INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2719,1006 +4742,2050 @@ fn c308_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 327 fn c309_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c309_l327_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } // Line 328 fn c310_l328_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c310_l328_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c310_l328_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c310_l328_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)], + ) + .unwrap() + .expect("Missing result in c310_l328_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 329 fn c311_l329_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c311_l329_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c311_l329_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c311_l329_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)], + ) + .unwrap() + .expect("Missing result in c311_l329_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 330 fn c312_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c312_l330_action_invoke"); - let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "add", + &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 331 fn c313_l331_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c313_l331_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c313_l331_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c313_l331_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c313_l331_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 332 fn c314_l332_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c314_l332_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c314_l332_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c314_l332_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c314_l332_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 333 fn c315_l333_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c315_l333_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c315_l333_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c315_l333_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c315_l333_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 334 fn c316_l334_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c316_l334_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c316_l334_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c316_l334_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c316_l334_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 335 fn c317_l335_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c317_l335_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c317_l335_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c317_l335_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c317_l335_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 336 fn c318_l336_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c318_l336_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c318_l336_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c318_l336_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c318_l336_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 337 fn c319_l337_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c319_l337_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c319_l337_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c319_l337_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c319_l337_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 338 fn c320_l338_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c320_l338_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c320_l338_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c320_l338_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c320_l338_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 339 fn c321_l339_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c321_l339_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c321_l339_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c321_l339_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c321_l339_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 340 fn c322_l340_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c322_l340_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c322_l340_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c322_l340_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c322_l340_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 341 fn c323_l341_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c323_l341_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c323_l341_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c323_l341_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c323_l341_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 342 fn c324_l342_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c324_l342_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c324_l342_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c324_l342_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c324_l342_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 343 fn c325_l343_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c325_l343_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c325_l343_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c325_l343_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c325_l343_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 344 fn c326_l344_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c326_l344_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c326_l344_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c326_l344_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c326_l344_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 345 fn c327_l345_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c327_l345_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c327_l345_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c327_l345_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c327_l345_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 346 fn c328_l346_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c328_l346_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c328_l346_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c328_l346_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c328_l346_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 347 fn c329_l347_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c329_l347_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c329_l347_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c329_l347_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c329_l347_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 348 fn c330_l348_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c330_l348_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c330_l348_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c330_l348_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c330_l348_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 349 fn c331_l349_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c331_l349_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c331_l349_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c331_l349_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c331_l349_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 350 fn c332_l350_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c332_l350_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c332_l350_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c332_l350_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c332_l350_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 351 fn c333_l351_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c333_l351_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c333_l351_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c333_l351_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c333_l351_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 352 fn c334_l352_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c334_l352_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c334_l352_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c334_l352_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c334_l352_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 353 fn c335_l353_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c335_l353_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c335_l353_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c335_l353_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c335_l353_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 354 fn c336_l354_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c336_l354_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c336_l354_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c336_l354_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c336_l354_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 355 fn c337_l355_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c337_l355_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c337_l355_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c337_l355_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c337_l355_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 356 fn c338_l356_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c338_l356_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c338_l356_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c338_l356_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c338_l356_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 357 fn c339_l357_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c339_l357_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c339_l357_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c339_l357_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c339_l357_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 358 fn c340_l358_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c340_l358_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c340_l358_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c340_l358_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c340_l358_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 359 fn c341_l359_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c341_l359_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c341_l359_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c341_l359_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c341_l359_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 360 fn c342_l360_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c342_l360_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c342_l360_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c342_l360_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c342_l360_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 361 fn c343_l361_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c343_l361_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c343_l361_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c343_l361_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c343_l361_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 362 fn c344_l362_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c344_l362_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c344_l362_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c344_l362_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c344_l362_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 363 fn c345_l363_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c345_l363_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c345_l363_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c345_l363_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c345_l363_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 364 fn c346_l364_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c346_l364_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c346_l364_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c346_l364_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c346_l364_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 365 fn c347_l365_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c347_l365_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c347_l365_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c347_l365_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c347_l365_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 366 fn c348_l366_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c348_l366_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c348_l366_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c348_l366_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c348_l366_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 367 fn c349_l367_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c349_l367_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c349_l367_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c349_l367_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c349_l367_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 368 fn c350_l368_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c350_l368_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c350_l368_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c350_l368_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c350_l368_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 369 fn c351_l369_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c351_l369_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c351_l369_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c351_l369_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c351_l369_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 370 fn c352_l370_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c352_l370_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c352_l370_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c352_l370_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c352_l370_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 371 fn c353_l371_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c353_l371_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c353_l371_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c353_l371_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c353_l371_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 372 fn c354_l372_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c354_l372_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c354_l372_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c354_l372_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c354_l372_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 373 fn c355_l373_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c355_l373_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c355_l373_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c355_l373_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c355_l373_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 374 fn c356_l374_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c356_l374_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c356_l374_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c356_l374_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c356_l374_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 375 fn c357_l375_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c357_l375_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c357_l375_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c357_l375_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c357_l375_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 376 fn c358_l376_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c358_l376_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c358_l376_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c358_l376_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c358_l376_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 377 fn c359_l377_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c359_l377_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c359_l377_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c359_l377_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c359_l377_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 378 fn c360_l378_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c360_l378_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c360_l378_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c360_l378_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c360_l378_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 379 fn c361_l379_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c361_l379_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c361_l379_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c361_l379_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c361_l379_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 380 fn c362_l380_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c362_l380_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c362_l380_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c362_l380_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c362_l380_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 381 fn c363_l381_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c363_l381_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c363_l381_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c363_l381_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c363_l381_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 382 fn c364_l382_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c364_l382_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c364_l382_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c364_l382_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c364_l382_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 383 fn c365_l383_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c365_l383_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c365_l383_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c365_l383_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c365_l383_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 384 fn c366_l384_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c366_l384_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c366_l384_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c366_l384_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c366_l384_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 385 fn c367_l385_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c367_l385_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c367_l385_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c367_l385_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c367_l385_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 386 fn c368_l386_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c368_l386_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c368_l386_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c368_l386_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c368_l386_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 387 fn c369_l387_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c369_l387_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c369_l387_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c369_l387_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c369_l387_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 388 fn c370_l388_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c370_l388_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c370_l388_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c370_l388_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c370_l388_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 389 fn c371_l389_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c371_l389_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c371_l389_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c371_l389_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c371_l389_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 390 fn c372_l390_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c372_l390_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c372_l390_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c372_l390_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c372_l390_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 391 fn c373_l391_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c373_l391_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c373_l391_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c373_l391_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c373_l391_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 392 fn c374_l392_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c374_l392_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c374_l392_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c374_l392_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c374_l392_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 393 fn c375_l393_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c375_l393_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c375_l393_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c375_l393_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c375_l393_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 394 fn c376_l394_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c376_l394_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c376_l394_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c376_l394_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c376_l394_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 395 fn c377_l395_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c377_l395_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c377_l395_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c377_l395_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c377_l395_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 396 fn c378_l396_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c378_l396_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c378_l396_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c378_l396_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c378_l396_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 397 fn c379_l397_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c379_l397_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c379_l397_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c379_l397_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c379_l397_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 398 fn c380_l398_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c380_l398_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c380_l398_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c380_l398_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c380_l398_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 399 fn c381_l399_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c381_l399_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c381_l399_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c381_l399_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c381_l399_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 400 fn c382_l400_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c382_l400_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c382_l400_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c382_l400_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c382_l400_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 401 fn c383_l401_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c383_l401_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c383_l401_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c383_l401_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c383_l401_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 402 fn c384_l402_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c384_l402_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c384_l402_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c384_l402_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c384_l402_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 403 fn c385_l403_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c385_l403_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c385_l403_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c385_l403_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c385_l403_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 404 fn c386_l404_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c386_l404_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c386_l404_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c386_l404_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c386_l404_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 405 fn c387_l405_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c387_l405_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c387_l405_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c387_l405_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c387_l405_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 406 fn c388_l406_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c388_l406_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c388_l406_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c388_l406_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c388_l406_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 407 fn c389_l407_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c389_l407_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c389_l407_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c389_l407_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c389_l407_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 408 fn c390_l408_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c390_l408_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c390_l408_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c390_l408_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c390_l408_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 409 fn c391_l409_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c391_l409_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c391_l409_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c391_l409_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c391_l409_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 410 fn c392_l410_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c392_l410_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c392_l410_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c392_l410_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c392_l410_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 411 fn c393_l411_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c393_l411_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c393_l411_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c393_l411_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c393_l411_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 412 fn c394_l412_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c394_l412_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c394_l412_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c394_l412_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c394_l412_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 413 fn c395_l413_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c395_l413_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c395_l413_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c395_l413_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c395_l413_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 414 fn c396_l414_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c396_l414_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c396_l414_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c396_l414_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c396_l414_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 415 fn c397_l415_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c397_l415_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c397_l415_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c397_l415_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c397_l415_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 416 fn c398_l416_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c398_l416_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c398_l416_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c398_l416_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c398_l416_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 417 fn c399_l417_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c399_l417_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c399_l417_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c399_l417_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c399_l417_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 418 fn c400_l418_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c400_l418_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c400_l418_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c400_l418_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c400_l418_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -3757,64 +6824,152 @@ fn c404_l422_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 423 fn c405_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c405_l423_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 424 fn c406_l424_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c406_l424_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 425 fn c407_l425_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c407_l425_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 426 fn c408_l426_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c408_l426_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 427 fn c409_l427_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c409_l427_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 428 fn c410_l428_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c410_l428_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 429 fn c411_l429_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c411_l429_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 430 fn c412_l430_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c412_l430_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } @@ -3917,39 +7072,86 @@ fn c424_l442_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 443 fn c425_l443_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c425_l443_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 444 fn c426_l444_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c426_l444_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 445 fn c427_l445_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c427_l445_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 446 fn c428_l446_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c428_l446_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 447 fn c429_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c429_l447_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -3965,7 +7167,10 @@ fn c430_l448_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 449 fn c431_l449_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c431_l449_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -3980,128 +7185,262 @@ fn c432_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 451 fn c433_l451_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c433_l451_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c433_l451_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c433_l451_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c433_l451_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 452 fn c434_l452_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c434_l452_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c434_l452_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c434_l452_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c434_l452_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 453 fn c435_l453_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c435_l453_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c435_l453_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c435_l453_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c435_l453_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 454 fn c436_l454_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c436_l454_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c436_l454_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c436_l454_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c436_l454_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 455 fn c437_l455_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c437_l455_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c437_l455_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c437_l455_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c437_l455_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 456 fn c438_l456_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c438_l456_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c438_l456_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c438_l456_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c438_l456_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 457 fn c439_l457_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c439_l457_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c439_l457_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c439_l457_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c439_l457_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 458 fn c440_l458_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c440_l458_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c440_l458_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c440_l458_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c440_l458_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 459 fn c441_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c441_l459_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 460 fn c442_l460_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c442_l460_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 461 fn c443_l461_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c443_l461_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 462 fn c444_l462_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c444_l462_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 463 fn c445_l463_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c445_l463_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -4109,23 +7448,51 @@ fn c445_l463_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 464 fn c446_l464_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c446_l464_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000003f32) + ))) + ); result.map(|_| ()) } // Line 465 fn c447_l465_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c447_l465_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000003f32) + ))) + ); result.map(|_| ()) } // Line 466 fn c448_l466_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c448_l466_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -4133,39 +7500,89 @@ fn c448_l466_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 467 fn c449_l467_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c449_l467_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754942f32) + ))) + ); result.map(|_| ()) } // Line 468 fn c450_l468_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c450_l468_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754945f32) + ))) + ); result.map(|_| ()) } // Line 469 fn c451_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c451_l469_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754945f32) + ))) + ); result.map(|_| ()) } // Line 470 fn c452_l470_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c452_l470_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754942f32) + ))) + ); result.map(|_| ()) } // Line 471 fn c453_l471_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c453_l471_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -4173,7 +7590,13 @@ fn c453_l471_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 472 fn c454_l472_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c454_l472_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -4181,7 +7604,13 @@ fn c454_l472_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 473 fn c455_l473_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c455_l473_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -4189,7 +7618,13 @@ fn c455_l473_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 474 fn c456_l474_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c456_l474_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -4197,7 +7632,13 @@ fn c456_l474_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 475 fn c457_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c457_l475_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -4205,7 +7646,13 @@ fn c457_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 476 fn c458_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c458_l476_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -4213,7 +7660,13 @@ fn c458_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 477 fn c459_l477_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c459_l477_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -4221,7 +7674,13 @@ fn c459_l477_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 478 fn c460_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c460_l478_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -4229,7 +7688,13 @@ fn c460_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 479 fn c461_l479_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c461_l479_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -4237,7 +7702,13 @@ fn c461_l479_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 480 fn c462_l480_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c462_l480_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -4245,7 +7716,13 @@ fn c462_l480_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 481 fn c463_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c463_l481_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -4253,7 +7730,13 @@ fn c463_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 482 fn c464_l482_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c464_l482_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -4261,39 +7744,89 @@ fn c464_l482_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 483 fn c465_l483_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c465_l483_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 484 fn c466_l484_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c466_l484_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 485 fn c467_l485_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c467_l485_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 486 fn c468_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c468_l486_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 487 fn c469_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c469_l487_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -4301,7 +7834,13 @@ fn c469_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 488 fn c470_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c470_l488_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -4309,7 +7848,13 @@ fn c470_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 489 fn c471_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c471_l489_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -4317,167 +7862,363 @@ fn c471_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 490 fn c472_l490_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c472_l490_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } // Line 491 fn c473_l491_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c473_l491_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c473_l491_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c473_l491_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c473_l491_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 492 fn c474_l492_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c474_l492_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c474_l492_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c474_l492_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c474_l492_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 493 fn c475_l493_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c475_l493_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c475_l493_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c475_l493_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c475_l493_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 494 fn c476_l494_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c476_l494_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c476_l494_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c476_l494_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c476_l494_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 495 fn c477_l495_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c477_l495_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c477_l495_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c477_l495_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c477_l495_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 496 fn c478_l496_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c478_l496_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c478_l496_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c478_l496_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c478_l496_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 497 fn c479_l497_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c479_l497_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c479_l497_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c479_l497_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c479_l497_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 498 fn c480_l498_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c480_l498_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c480_l498_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c480_l498_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c480_l498_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 499 fn c481_l499_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c481_l499_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 500 fn c482_l500_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c482_l500_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 501 fn c483_l501_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c483_l501_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 502 fn c484_l502_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c484_l502_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 503 fn c485_l503_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c485_l503_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754942f32) + ))) + ); result.map(|_| ()) } // Line 504 fn c486_l504_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c486_l504_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754945f32) + ))) + ); result.map(|_| ()) } // Line 505 fn c487_l505_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c487_l505_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754945f32) + ))) + ); result.map(|_| ()) } // Line 506 fn c488_l506_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c488_l506_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754942f32) + ))) + ); result.map(|_| ()) } // Line 507 fn c489_l507_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c489_l507_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -4485,23 +8226,51 @@ fn c489_l507_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 508 fn c490_l508_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c490_l508_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000023509887f32) + ))) + ); result.map(|_| ()) } // Line 509 fn c491_l509_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c491_l509_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000023509887f32) + ))) + ); result.map(|_| ()) } // Line 510 fn c492_l510_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c492_l510_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -4509,7 +8278,13 @@ fn c492_l510_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 511 fn c493_l511_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c493_l511_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -4517,7 +8292,13 @@ fn c493_l511_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 512 fn c494_l512_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c494_l512_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -4525,7 +8306,13 @@ fn c494_l512_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 513 fn c495_l513_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c495_l513_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -4533,7 +8320,13 @@ fn c495_l513_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 514 fn c496_l514_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c496_l514_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -4541,7 +8334,13 @@ fn c496_l514_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 515 fn c497_l515_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c497_l515_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -4549,7 +8348,13 @@ fn c497_l515_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 516 fn c498_l516_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c498_l516_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -4557,7 +8362,13 @@ fn c498_l516_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 517 fn c499_l517_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c499_l517_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -4565,7 +8376,13 @@ fn c499_l517_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 518 fn c500_l518_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c500_l518_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -4573,7 +8390,13 @@ fn c500_l518_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 519 fn c501_l519_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c501_l519_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -4581,7 +8404,13 @@ fn c501_l519_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 520 fn c502_l520_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c502_l520_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -4589,7 +8418,13 @@ fn c502_l520_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 521 fn c503_l521_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c503_l521_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -4597,7 +8432,13 @@ fn c503_l521_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 522 fn c504_l522_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c504_l522_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -4605,39 +8446,89 @@ fn c504_l522_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 523 fn c505_l523_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c505_l523_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 524 fn c506_l524_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c506_l524_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 525 fn c507_l525_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c507_l525_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 526 fn c508_l526_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c508_l526_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 527 fn c509_l527_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c509_l527_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -4645,7 +8536,13 @@ fn c509_l527_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 528 fn c510_l528_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c510_l528_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -4653,7 +8550,13 @@ fn c510_l528_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 529 fn c511_l529_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c511_l529_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -4661,96 +8564,198 @@ fn c511_l529_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 530 fn c512_l530_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c512_l530_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } // Line 531 fn c513_l531_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c513_l531_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c513_l531_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c513_l531_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c513_l531_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 532 fn c514_l532_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c514_l532_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c514_l532_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c514_l532_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c514_l532_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 533 fn c515_l533_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c515_l533_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c515_l533_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c515_l533_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c515_l533_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 534 fn c516_l534_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c516_l534_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c516_l534_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c516_l534_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c516_l534_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 535 fn c517_l535_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c517_l535_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c517_l535_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c517_l535_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c517_l535_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 536 fn c518_l536_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c518_l536_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c518_l536_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c518_l536_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c518_l536_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 537 fn c519_l537_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c519_l537_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c519_l537_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c519_l537_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c519_l537_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 538 fn c520_l538_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c520_l538_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c520_l538_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c520_l538_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c520_l538_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -4789,7 +8794,13 @@ fn c524_l542_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 543 fn c525_l543_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c525_l543_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -4797,7 +8808,13 @@ fn c525_l543_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 544 fn c526_l544_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c526_l544_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -4805,7 +8822,13 @@ fn c526_l544_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 545 fn c527_l545_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c527_l545_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -4813,7 +8836,13 @@ fn c527_l545_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 546 fn c528_l546_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c528_l546_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -4821,7 +8850,13 @@ fn c528_l546_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 547 fn c529_l547_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c529_l547_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -4829,7 +8864,13 @@ fn c529_l547_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 548 fn c530_l548_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c530_l548_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -4837,7 +8878,13 @@ fn c530_l548_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 549 fn c531_l549_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c531_l549_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -4845,7 +8892,13 @@ fn c531_l549_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 550 fn c532_l550_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c532_l550_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -4949,39 +9002,86 @@ fn c544_l562_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 563 fn c545_l563_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c545_l563_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 564 fn c546_l564_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c546_l564_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 565 fn c547_l565_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c547_l565_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 566 fn c548_l566_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c548_l566_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 567 fn c549_l567_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c549_l567_action_invoke"); - let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -4997,7 +9097,10 @@ fn c550_l568_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 569 fn c551_l569_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c551_l569_action_invoke"); - let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -5012,89 +9115,173 @@ fn c552_l570_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 571 fn c553_l571_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c553_l571_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c553_l571_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c553_l571_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c553_l571_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 572 fn c554_l572_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c554_l572_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c554_l572_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c554_l572_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c554_l572_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 573 fn c555_l573_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c555_l573_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c555_l573_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c555_l573_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c555_l573_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 574 fn c556_l574_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c556_l574_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c556_l574_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c556_l574_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c556_l574_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 575 fn c557_l575_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c557_l575_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c557_l575_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c557_l575_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c557_l575_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 576 fn c558_l576_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c558_l576_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c558_l576_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c558_l576_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c558_l576_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 577 fn c559_l577_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c559_l577_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c559_l577_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c559_l577_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c559_l577_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 578 fn c560_l578_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c560_l578_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c560_l578_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c560_l578_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c560_l578_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -5133,7 +9320,13 @@ fn c564_l582_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 583 fn c565_l583_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c565_l583_action_invoke"); - let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -5141,7 +9334,13 @@ fn c565_l583_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 584 fn c566_l584_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c566_l584_action_invoke"); - let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -5149,7 +9348,13 @@ fn c566_l584_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 585 fn c567_l585_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c567_l585_action_invoke"); - let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -5157,7 +9362,13 @@ fn c567_l585_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 586 fn c568_l586_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c568_l586_action_invoke"); - let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -5165,7 +9376,13 @@ fn c568_l586_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 587 fn c569_l587_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c569_l587_action_invoke"); - let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -5173,7 +9390,13 @@ fn c569_l587_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 588 fn c570_l588_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c570_l588_action_invoke"); - let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -5181,7 +9404,13 @@ fn c570_l588_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 589 fn c571_l589_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c571_l589_action_invoke"); - let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -5189,7 +9418,13 @@ fn c571_l589_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 590 fn c572_l590_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c572_l590_action_invoke"); - let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -5293,39 +9528,86 @@ fn c584_l602_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 603 fn c585_l603_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c585_l603_action_invoke"); - let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 604 fn c586_l604_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c586_l604_action_invoke"); - let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 605 fn c587_l605_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c587_l605_action_invoke"); - let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 606 fn c588_l606_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c588_l606_action_invoke"); - let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 607 fn c589_l607_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c589_l607_action_invoke"); - let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -5341,7 +9623,10 @@ fn c590_l608_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 609 fn c591_l609_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c591_l609_action_invoke"); - let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -5356,89 +9641,173 @@ fn c592_l610_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 611 fn c593_l611_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c593_l611_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c593_l611_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c593_l611_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c593_l611_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 612 fn c594_l612_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c594_l612_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c594_l612_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c594_l612_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c594_l612_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 613 fn c595_l613_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c595_l613_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c595_l613_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c595_l613_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c595_l613_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 614 fn c596_l614_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c596_l614_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c596_l614_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c596_l614_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c596_l614_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 615 fn c597_l615_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c597_l615_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c597_l615_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c597_l615_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c597_l615_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 616 fn c598_l616_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c598_l616_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c598_l616_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c598_l616_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c598_l616_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 617 fn c599_l617_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c599_l617_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c599_l617_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c599_l617_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c599_l617_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 618 fn c600_l618_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c600_l618_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c600_l618_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c600_l618_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c600_l618_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -5477,7 +9846,13 @@ fn c604_l622_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 623 fn c605_l623_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c605_l623_action_invoke"); - let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -5485,7 +9860,13 @@ fn c605_l623_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 624 fn c606_l624_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c606_l624_action_invoke"); - let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -5493,7 +9874,13 @@ fn c606_l624_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 625 fn c607_l625_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c607_l625_action_invoke"); - let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -5501,7 +9888,13 @@ fn c607_l625_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 626 fn c608_l626_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c608_l626_action_invoke"); - let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -5509,7 +9902,13 @@ fn c608_l626_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 627 fn c609_l627_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c609_l627_action_invoke"); - let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -5517,7 +9916,13 @@ fn c609_l627_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 628 fn c610_l628_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c610_l628_action_invoke"); - let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -5525,7 +9930,13 @@ fn c610_l628_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 629 fn c611_l629_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c611_l629_action_invoke"); - let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -5533,7 +9944,13 @@ fn c611_l629_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 630 fn c612_l630_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c612_l630_action_invoke"); - let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -5605,7 +10022,10 @@ fn c620_l638_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 639 fn c621_l639_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c621_l639_action_invoke"); - let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "sub", + &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5613,7 +10033,10 @@ fn c621_l639_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 640 fn c622_l640_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c622_l640_action_invoke"); - let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "sub", + &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-12.566371f32))))); result.map(|_| ()) } @@ -5621,7 +10044,10 @@ fn c622_l640_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 641 fn c623_l641_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c623_l641_action_invoke"); - let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "sub", + &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((12.566371f32))))); result.map(|_| ()) } @@ -5629,7 +10055,10 @@ fn c623_l641_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 642 fn c624_l642_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c624_l642_action_invoke"); - let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "sub", + &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5637,39 +10066,86 @@ fn c624_l642_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 643 fn c625_l643_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c625_l643_action_invoke"); - let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 644 fn c626_l644_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c626_l644_action_invoke"); - let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 645 fn c627_l645_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c627_l645_action_invoke"); - let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 646 fn c628_l646_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c628_l646_action_invoke"); - let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 647 fn c629_l647_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c629_l647_action_invoke"); - let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -5677,7 +10153,10 @@ fn c629_l647_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 648 fn c630_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c630_l648_action_invoke"); - let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "sub", + &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -5685,7 +10164,10 @@ fn c630_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 649 fn c631_l649_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c631_l649_action_invoke"); - let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -5693,295 +10175,664 @@ fn c631_l649_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 650 fn c632_l650_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c632_l650_action_invoke"); - let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "sub", + &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } // Line 651 fn c633_l651_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c633_l651_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c633_l651_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c633_l651_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c633_l651_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 652 fn c634_l652_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c634_l652_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c634_l652_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c634_l652_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c634_l652_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 653 fn c635_l653_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c635_l653_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c635_l653_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c635_l653_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c635_l653_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 654 fn c636_l654_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c636_l654_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c636_l654_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c636_l654_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c636_l654_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 655 fn c637_l655_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c637_l655_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c637_l655_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c637_l655_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c637_l655_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 656 fn c638_l656_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c638_l656_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c638_l656_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c638_l656_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c638_l656_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 657 fn c639_l657_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c639_l657_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c639_l657_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c639_l657_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c639_l657_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 658 fn c640_l658_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c640_l658_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c640_l658_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c640_l658_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c640_l658_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 659 fn c641_l659_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c641_l659_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 660 fn c642_l660_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c642_l660_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 661 fn c643_l661_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c643_l661_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 662 fn c644_l662_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c644_l662_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 663 fn c645_l663_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c645_l663_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 664 fn c646_l664_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c646_l664_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 665 fn c647_l665_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c647_l665_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 666 fn c648_l666_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c648_l666_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 667 fn c649_l667_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c649_l667_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 668 fn c650_l668_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c650_l668_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 669 fn c651_l669_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c651_l669_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 670 fn c652_l670_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c652_l670_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 671 fn c653_l671_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c653_l671_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 672 fn c654_l672_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c654_l672_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 673 fn c655_l673_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c655_l673_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 674 fn c656_l674_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c656_l674_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 675 fn c657_l675_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c657_l675_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 676 fn c658_l676_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c658_l676_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 677 fn c659_l677_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c659_l677_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 678 fn c660_l678_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c660_l678_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 679 fn c661_l679_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c661_l679_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 680 fn c662_l680_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c662_l680_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 681 fn c663_l681_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c663_l681_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 682 fn c664_l682_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c664_l682_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 683 fn c665_l683_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c665_l683_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5989,7 +10840,13 @@ fn c665_l683_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 684 fn c666_l684_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c666_l684_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -5997,7 +10854,13 @@ fn c666_l684_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 685 fn c667_l685_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c667_l685_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -6005,7 +10868,13 @@ fn c667_l685_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 686 fn c668_l686_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c668_l686_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -6013,7 +10882,13 @@ fn c668_l686_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 687 fn c669_l687_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c669_l687_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -6021,7 +10896,13 @@ fn c669_l687_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 688 fn c670_l688_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c670_l688_action_invoke"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6029,7 +10910,13 @@ fn c670_l688_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 689 fn c671_l689_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c671_l689_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -6037,103 +10924,208 @@ fn c671_l689_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 690 fn c672_l690_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c672_l690_action_invoke"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } // Line 691 fn c673_l691_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c673_l691_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c673_l691_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c673_l691_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c673_l691_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 692 fn c674_l692_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c674_l692_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c674_l692_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c674_l692_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c674_l692_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 693 fn c675_l693_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c675_l693_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c675_l693_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c675_l693_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c675_l693_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 694 fn c676_l694_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c676_l694_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c676_l694_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c676_l694_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c676_l694_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 695 fn c677_l695_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c677_l695_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c677_l695_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c677_l695_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c677_l695_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 696 fn c678_l696_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c678_l696_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c678_l696_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c678_l696_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c678_l696_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 697 fn c679_l697_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c679_l697_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c679_l697_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c679_l697_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c679_l697_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 698 fn c680_l698_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c680_l698_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c680_l698_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c680_l698_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c680_l698_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 699 fn c681_l699_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c681_l699_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]); + let result = instance.call( + "sub", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6141,7 +11133,10 @@ fn c681_l699_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 700 fn c682_l700_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c682_l700_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))]); + let result = instance.call( + "sub", + &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6165,7 +11160,13 @@ fn c684_l702_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 703 fn c685_l703_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c685_l703_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6173,7 +11174,13 @@ fn c685_l703_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 704 fn c686_l704_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c686_l704_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6181,7 +11188,13 @@ fn c686_l704_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 705 fn c687_l705_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c687_l705_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -6189,7 +11202,13 @@ fn c687_l705_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 706 fn c688_l706_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c688_l706_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "sub", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -6197,7 +11216,13 @@ fn c688_l706_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 707 fn c689_l707_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c689_l707_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6205,7 +11230,13 @@ fn c689_l707_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 708 fn c690_l708_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c690_l708_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6213,7 +11244,13 @@ fn c690_l708_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 709 fn c691_l709_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c691_l709_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -6221,7 +11258,13 @@ fn c691_l709_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 710 fn c692_l710_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c692_l710_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "sub", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -6229,7 +11272,10 @@ fn c692_l710_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 711 fn c693_l711_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c693_l711_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]); + let result = instance.call( + "sub", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6237,7 +11283,10 @@ fn c693_l711_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 712 fn c694_l712_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c694_l712_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))]); + let result = instance.call( + "sub", + &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6261,7 +11310,10 @@ fn c696_l714_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 715 fn c697_l715_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c697_l715_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]); + let result = instance.call( + "sub", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6269,7 +11321,10 @@ fn c697_l715_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 716 fn c698_l716_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c698_l716_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))]); + let result = instance.call( + "sub", + &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6293,7 +11348,10 @@ fn c700_l718_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 719 fn c701_l719_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c701_l719_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "sub", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6301,7 +11359,10 @@ fn c701_l719_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 720 fn c702_l720_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c702_l720_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "sub", + &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6309,7 +11370,10 @@ fn c702_l720_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 721 fn c703_l721_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c703_l721_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "sub", + &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -6317,7 +11381,10 @@ fn c703_l721_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 722 fn c704_l722_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c704_l722_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "sub", + &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -6325,7 +11392,13 @@ fn c704_l722_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 723 fn c705_l723_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c705_l723_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6333,7 +11406,13 @@ fn c705_l723_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 724 fn c706_l724_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c706_l724_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6341,7 +11420,13 @@ fn c706_l724_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 725 fn c707_l725_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c707_l725_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32(f32::INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -6349,26 +11434,44 @@ fn c707_l725_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 726 fn c708_l726_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c708_l726_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "sub", + &[ + Value::F32(f32::INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 727 fn c709_l727_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c709_l727_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c709_l727_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c709_l727_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)], + ) + .unwrap() + .expect("Missing result in c709_l727_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 728 fn c710_l728_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c710_l728_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "sub", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -6376,987 +11479,2019 @@ fn c710_l728_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 729 fn c711_l729_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c711_l729_action_invoke"); - let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 730 fn c712_l730_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c712_l730_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c712_l730_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c712_l730_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)], + ) + .unwrap() + .expect("Missing result in c712_l730_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 731 fn c713_l731_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c713_l731_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c713_l731_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c713_l731_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c713_l731_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 732 fn c714_l732_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c714_l732_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c714_l732_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c714_l732_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c714_l732_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 733 fn c715_l733_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c715_l733_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c715_l733_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c715_l733_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c715_l733_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 734 fn c716_l734_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c716_l734_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c716_l734_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c716_l734_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c716_l734_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 735 fn c717_l735_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c717_l735_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c717_l735_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c717_l735_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c717_l735_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 736 fn c718_l736_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c718_l736_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c718_l736_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c718_l736_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c718_l736_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 737 fn c719_l737_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c719_l737_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c719_l737_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c719_l737_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c719_l737_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 738 fn c720_l738_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c720_l738_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c720_l738_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c720_l738_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c720_l738_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 739 fn c721_l739_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c721_l739_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c721_l739_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c721_l739_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c721_l739_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 740 fn c722_l740_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c722_l740_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c722_l740_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c722_l740_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c722_l740_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 741 fn c723_l741_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c723_l741_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c723_l741_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c723_l741_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c723_l741_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 742 fn c724_l742_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c724_l742_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c724_l742_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c724_l742_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c724_l742_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 743 fn c725_l743_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c725_l743_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c725_l743_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c725_l743_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c725_l743_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 744 fn c726_l744_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c726_l744_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c726_l744_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c726_l744_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c726_l744_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 745 fn c727_l745_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c727_l745_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c727_l745_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c727_l745_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c727_l745_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 746 fn c728_l746_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c728_l746_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c728_l746_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c728_l746_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c728_l746_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 747 fn c729_l747_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c729_l747_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c729_l747_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c729_l747_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c729_l747_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 748 fn c730_l748_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c730_l748_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c730_l748_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c730_l748_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c730_l748_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 749 fn c731_l749_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c731_l749_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c731_l749_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c731_l749_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c731_l749_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 750 fn c732_l750_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c732_l750_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c732_l750_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c732_l750_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c732_l750_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 751 fn c733_l751_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c733_l751_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c733_l751_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c733_l751_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c733_l751_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 752 fn c734_l752_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c734_l752_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c734_l752_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c734_l752_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c734_l752_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 753 fn c735_l753_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c735_l753_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c735_l753_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c735_l753_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c735_l753_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 754 fn c736_l754_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c736_l754_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c736_l754_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c736_l754_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c736_l754_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 755 fn c737_l755_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c737_l755_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c737_l755_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c737_l755_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c737_l755_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 756 fn c738_l756_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c738_l756_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c738_l756_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c738_l756_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c738_l756_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 757 fn c739_l757_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c739_l757_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c739_l757_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c739_l757_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c739_l757_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 758 fn c740_l758_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c740_l758_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c740_l758_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c740_l758_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c740_l758_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 759 fn c741_l759_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c741_l759_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c741_l759_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c741_l759_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c741_l759_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 760 fn c742_l760_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c742_l760_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c742_l760_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c742_l760_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c742_l760_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 761 fn c743_l761_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c743_l761_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c743_l761_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c743_l761_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c743_l761_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 762 fn c744_l762_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c744_l762_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c744_l762_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c744_l762_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c744_l762_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 763 fn c745_l763_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c745_l763_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c745_l763_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c745_l763_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c745_l763_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 764 fn c746_l764_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c746_l764_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c746_l764_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c746_l764_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c746_l764_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 765 fn c747_l765_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c747_l765_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c747_l765_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c747_l765_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c747_l765_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 766 fn c748_l766_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c748_l766_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c748_l766_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c748_l766_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c748_l766_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 767 fn c749_l767_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c749_l767_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c749_l767_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c749_l767_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c749_l767_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 768 fn c750_l768_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c750_l768_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c750_l768_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c750_l768_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c750_l768_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 769 fn c751_l769_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c751_l769_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c751_l769_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c751_l769_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c751_l769_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 770 fn c752_l770_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c752_l770_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c752_l770_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c752_l770_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c752_l770_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 771 fn c753_l771_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c753_l771_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c753_l771_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c753_l771_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c753_l771_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 772 fn c754_l772_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c754_l772_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c754_l772_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c754_l772_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c754_l772_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 773 fn c755_l773_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c755_l773_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c755_l773_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c755_l773_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c755_l773_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 774 fn c756_l774_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c756_l774_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c756_l774_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c756_l774_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c756_l774_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 775 fn c757_l775_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c757_l775_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c757_l775_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c757_l775_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c757_l775_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 776 fn c758_l776_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c758_l776_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c758_l776_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c758_l776_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c758_l776_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 777 fn c759_l777_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c759_l777_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c759_l777_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c759_l777_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c759_l777_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 778 fn c760_l778_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c760_l778_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c760_l778_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c760_l778_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c760_l778_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 779 fn c761_l779_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c761_l779_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c761_l779_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c761_l779_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c761_l779_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 780 fn c762_l780_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c762_l780_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c762_l780_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c762_l780_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c762_l780_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 781 fn c763_l781_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c763_l781_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c763_l781_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c763_l781_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c763_l781_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 782 fn c764_l782_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c764_l782_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c764_l782_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c764_l782_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c764_l782_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 783 fn c765_l783_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c765_l783_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c765_l783_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c765_l783_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c765_l783_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 784 fn c766_l784_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c766_l784_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c766_l784_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c766_l784_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c766_l784_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 785 fn c767_l785_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c767_l785_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c767_l785_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c767_l785_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c767_l785_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 786 fn c768_l786_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c768_l786_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c768_l786_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c768_l786_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c768_l786_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 787 fn c769_l787_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c769_l787_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c769_l787_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c769_l787_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c769_l787_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 788 fn c770_l788_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c770_l788_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c770_l788_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c770_l788_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c770_l788_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 789 fn c771_l789_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c771_l789_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c771_l789_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c771_l789_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c771_l789_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 790 fn c772_l790_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c772_l790_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c772_l790_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c772_l790_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c772_l790_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 791 fn c773_l791_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c773_l791_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c773_l791_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c773_l791_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c773_l791_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 792 fn c774_l792_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c774_l792_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c774_l792_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c774_l792_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c774_l792_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 793 fn c775_l793_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c775_l793_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c775_l793_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c775_l793_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c775_l793_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 794 fn c776_l794_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c776_l794_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c776_l794_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c776_l794_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c776_l794_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 795 fn c777_l795_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c777_l795_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c777_l795_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c777_l795_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c777_l795_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 796 fn c778_l796_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c778_l796_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c778_l796_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c778_l796_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c778_l796_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 797 fn c779_l797_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c779_l797_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c779_l797_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c779_l797_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c779_l797_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 798 fn c780_l798_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c780_l798_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c780_l798_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c780_l798_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c780_l798_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 799 fn c781_l799_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c781_l799_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c781_l799_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c781_l799_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c781_l799_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 800 fn c782_l800_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c782_l800_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c782_l800_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c782_l800_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c782_l800_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 801 fn c783_l801_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c783_l801_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c783_l801_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c783_l801_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c783_l801_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 802 fn c784_l802_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c784_l802_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c784_l802_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c784_l802_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c784_l802_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 803 fn c785_l803_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c785_l803_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c785_l803_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c785_l803_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c785_l803_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 804 fn c786_l804_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c786_l804_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c786_l804_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c786_l804_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c786_l804_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 805 fn c787_l805_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c787_l805_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c787_l805_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c787_l805_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c787_l805_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 806 fn c788_l806_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c788_l806_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c788_l806_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c788_l806_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c788_l806_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 807 fn c789_l807_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c789_l807_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c789_l807_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c789_l807_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c789_l807_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 808 fn c790_l808_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c790_l808_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c790_l808_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c790_l808_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c790_l808_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 809 fn c791_l809_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c791_l809_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c791_l809_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c791_l809_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c791_l809_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 810 fn c792_l810_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c792_l810_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c792_l810_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c792_l810_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c792_l810_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 811 fn c793_l811_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c793_l811_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c793_l811_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c793_l811_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c793_l811_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 812 fn c794_l812_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c794_l812_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c794_l812_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c794_l812_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c794_l812_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 813 fn c795_l813_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c795_l813_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c795_l813_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c795_l813_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c795_l813_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 814 fn c796_l814_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c796_l814_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c796_l814_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c796_l814_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c796_l814_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 815 fn c797_l815_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c797_l815_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c797_l815_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c797_l815_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c797_l815_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 816 fn c798_l816_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c798_l816_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c798_l816_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c798_l816_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c798_l816_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 817 fn c799_l817_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c799_l817_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c799_l817_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c799_l817_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c799_l817_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 818 fn c800_l818_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c800_l818_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c800_l818_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c800_l818_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c800_l818_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -7395,7 +13530,13 @@ fn c804_l822_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 823 fn c805_l823_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c805_l823_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -7403,7 +13544,13 @@ fn c805_l823_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 824 fn c806_l824_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c806_l824_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -7411,7 +13558,13 @@ fn c806_l824_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 825 fn c807_l825_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c807_l825_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -7419,7 +13572,13 @@ fn c807_l825_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 826 fn c808_l826_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c808_l826_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -7427,7 +13586,13 @@ fn c808_l826_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 827 fn c809_l827_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c809_l827_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -7435,7 +13600,13 @@ fn c809_l827_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 828 fn c810_l828_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c810_l828_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -7443,7 +13614,13 @@ fn c810_l828_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 829 fn c811_l829_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c811_l829_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -7451,7 +13628,13 @@ fn c811_l829_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 830 fn c812_l830_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c812_l830_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -7555,7 +13738,13 @@ fn c824_l842_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 843 fn c825_l843_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c825_l843_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -7563,7 +13752,13 @@ fn c825_l843_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 844 fn c826_l844_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c826_l844_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -7571,7 +13766,13 @@ fn c826_l844_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 845 fn c827_l845_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c827_l845_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -7579,147 +13780,273 @@ fn c827_l845_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 846 fn c828_l846_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c828_l846_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } // Line 847 fn c829_l847_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c829_l847_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c829_l847_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c829_l847_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)], + ) + .unwrap() + .expect("Missing result in c829_l847_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 848 fn c830_l848_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c830_l848_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c830_l848_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c830_l848_assert_return_canonical_nan" + ); + let result = instance + .call("mul", &[Value::F32((-0.0f32)), Value::F32(f32::INFINITY)]) + .unwrap() + .expect("Missing result in c830_l848_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 849 fn c831_l849_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c831_l849_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c831_l849_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c831_l849_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)], + ) + .unwrap() + .expect("Missing result in c831_l849_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 850 fn c832_l850_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c832_l850_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c832_l850_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c832_l850_assert_return_canonical_nan" + ); + let result = instance + .call("mul", &[Value::F32((0.0f32)), Value::F32(f32::INFINITY)]) + .unwrap() + .expect("Missing result in c832_l850_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 851 fn c833_l851_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c833_l851_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c833_l851_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c833_l851_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c833_l851_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 852 fn c834_l852_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c834_l852_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c834_l852_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c834_l852_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c834_l852_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 853 fn c835_l853_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c835_l853_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c835_l853_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c835_l853_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c835_l853_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 854 fn c836_l854_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c836_l854_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c836_l854_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c836_l854_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c836_l854_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 855 fn c837_l855_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c837_l855_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c837_l855_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c837_l855_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c837_l855_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 856 fn c838_l856_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c838_l856_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c838_l856_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c838_l856_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c838_l856_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 857 fn c839_l857_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c839_l857_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c839_l857_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c839_l857_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c839_l857_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 858 fn c840_l858_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c840_l858_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c840_l858_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c840_l858_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c840_l858_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 859 fn c841_l859_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c841_l859_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -7727,7 +14054,13 @@ fn c841_l859_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 860 fn c842_l860_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c842_l860_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -7735,7 +14068,13 @@ fn c842_l860_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 861 fn c843_l861_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c843_l861_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -7743,7 +14082,13 @@ fn c843_l861_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 862 fn c844_l862_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c844_l862_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -7751,7 +14096,13 @@ fn c844_l862_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 863 fn c845_l863_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c845_l863_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -7759,7 +14110,13 @@ fn c845_l863_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 864 fn c846_l864_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c846_l864_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -7767,7 +14124,13 @@ fn c846_l864_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 865 fn c847_l865_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c847_l865_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -7775,7 +14138,13 @@ fn c847_l865_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 866 fn c848_l866_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c848_l866_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -7783,7 +14152,13 @@ fn c848_l866_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 867 fn c849_l867_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c849_l867_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -7791,7 +14166,13 @@ fn c849_l867_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 868 fn c850_l868_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c850_l868_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -7799,7 +14180,13 @@ fn c850_l868_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 869 fn c851_l869_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c851_l869_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -7807,7 +14194,13 @@ fn c851_l869_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 870 fn c852_l870_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c852_l870_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -7815,7 +14208,13 @@ fn c852_l870_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 871 fn c853_l871_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c853_l871_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -7823,7 +14222,13 @@ fn c853_l871_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 872 fn c854_l872_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c854_l872_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -7831,7 +14236,13 @@ fn c854_l872_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 873 fn c855_l873_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c855_l873_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -7839,7 +14250,13 @@ fn c855_l873_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 874 fn c856_l874_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c856_l874_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -7847,71 +14264,165 @@ fn c856_l874_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 875 fn c857_l875_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c857_l875_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 876 fn c858_l876_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c858_l876_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 877 fn c859_l877_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c859_l877_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 878 fn c860_l878_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c860_l878_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 879 fn c861_l879_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c861_l879_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000008f32) + ))) + ); result.map(|_| ()) } // Line 880 fn c862_l880_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c862_l880_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000008f32) + ))) + ); result.map(|_| ()) } // Line 881 fn c863_l881_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c863_l881_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000008f32) + ))) + ); result.map(|_| ()) } // Line 882 fn c864_l882_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c864_l882_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000008f32) + ))) + ); result.map(|_| ()) } // Line 883 fn c865_l883_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c865_l883_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32))))); result.map(|_| ()) } @@ -7919,7 +14430,13 @@ fn c865_l883_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 884 fn c866_l884_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c866_l884_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32))))); result.map(|_| ()) } @@ -7927,7 +14444,13 @@ fn c866_l884_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 885 fn c867_l885_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c867_l885_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32))))); result.map(|_| ()) } @@ -7935,7 +14458,13 @@ fn c867_l885_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 886 fn c868_l886_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c868_l886_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32))))); result.map(|_| ()) } @@ -7943,7 +14472,13 @@ fn c868_l886_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 887 fn c869_l887_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c869_l887_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -7951,7 +14486,13 @@ fn c869_l887_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 888 fn c870_l888_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c870_l888_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -7959,7 +14500,13 @@ fn c870_l888_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 889 fn c871_l889_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c871_l889_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -7967,103 +14514,211 @@ fn c871_l889_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 890 fn c872_l890_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c872_l890_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 891 fn c873_l891_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c873_l891_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c873_l891_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c873_l891_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c873_l891_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 892 fn c874_l892_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c874_l892_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c874_l892_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c874_l892_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c874_l892_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 893 fn c875_l893_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c875_l893_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c875_l893_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c875_l893_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c875_l893_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 894 fn c876_l894_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c876_l894_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c876_l894_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c876_l894_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c876_l894_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 895 fn c877_l895_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c877_l895_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c877_l895_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c877_l895_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c877_l895_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 896 fn c878_l896_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c878_l896_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c878_l896_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c878_l896_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c878_l896_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 897 fn c879_l897_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c879_l897_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c879_l897_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c879_l897_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c879_l897_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 898 fn c880_l898_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c880_l898_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c880_l898_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c880_l898_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c880_l898_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 899 fn c881_l899_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c881_l899_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -8071,7 +14726,13 @@ fn c881_l899_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 900 fn c882_l900_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c882_l900_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8079,7 +14740,13 @@ fn c882_l900_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 901 fn c883_l901_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c883_l901_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8087,7 +14754,13 @@ fn c883_l901_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 902 fn c884_l902_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c884_l902_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -8095,7 +14768,13 @@ fn c884_l902_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 903 fn c885_l903_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c885_l903_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -8103,7 +14782,13 @@ fn c885_l903_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 904 fn c886_l904_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c886_l904_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8111,7 +14796,13 @@ fn c886_l904_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 905 fn c887_l905_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c887_l905_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8119,7 +14810,13 @@ fn c887_l905_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 906 fn c888_l906_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c888_l906_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -8127,7 +14824,13 @@ fn c888_l906_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 907 fn c889_l907_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c889_l907_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -8135,7 +14838,13 @@ fn c889_l907_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 908 fn c890_l908_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c890_l908_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8143,7 +14852,13 @@ fn c890_l908_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 909 fn c891_l909_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c891_l909_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8151,7 +14866,13 @@ fn c891_l909_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 910 fn c892_l910_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c892_l910_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -8159,103 +14880,241 @@ fn c892_l910_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 911 fn c893_l911_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c893_l911_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000005877472f32) + ))) + ); result.map(|_| ()) } // Line 912 fn c894_l912_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c894_l912_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000005877472f32) + ))) + ); result.map(|_| ()) } // Line 913 fn c895_l913_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c895_l913_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000005877472f32) + ))) + ); result.map(|_| ()) } // Line 914 fn c896_l914_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c896_l914_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000005877472f32) + ))) + ); result.map(|_| ()) } // Line 915 fn c897_l915_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c897_l915_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 916 fn c898_l916_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c898_l916_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 917 fn c899_l917_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c899_l917_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 918 fn c900_l918_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c900_l918_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 919 fn c901_l919_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c901_l919_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.00000000000000000000000000000000000007385849f32) + ))) + ); result.map(|_| ()) } // Line 920 fn c902_l920_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c902_l920_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.00000000000000000000000000000000000007385849f32) + ))) + ); result.map(|_| ()) } // Line 921 fn c903_l921_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c903_l921_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.00000000000000000000000000000000000007385849f32) + ))) + ); result.map(|_| ()) } // Line 922 fn c904_l922_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c904_l922_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.00000000000000000000000000000000000007385849f32) + ))) + ); result.map(|_| ()) } // Line 923 fn c905_l923_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c905_l923_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((3.9999998f32))))); result.map(|_| ()) } @@ -8263,7 +15122,13 @@ fn c905_l923_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 924 fn c906_l924_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c906_l924_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32))))); result.map(|_| ()) } @@ -8271,7 +15136,13 @@ fn c906_l924_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 925 fn c907_l925_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c907_l925_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32))))); result.map(|_| ()) } @@ -8279,7 +15150,13 @@ fn c907_l925_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 926 fn c908_l926_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c908_l926_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((3.9999998f32))))); result.map(|_| ()) } @@ -8287,7 +15164,13 @@ fn c908_l926_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 927 fn c909_l927_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c909_l927_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -8295,7 +15178,13 @@ fn c909_l927_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 928 fn c910_l928_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c910_l928_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -8303,7 +15192,13 @@ fn c910_l928_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 929 fn c911_l929_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c911_l929_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -8311,96 +15206,198 @@ fn c911_l929_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 930 fn c912_l930_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c912_l930_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 931 fn c913_l931_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c913_l931_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c913_l931_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c913_l931_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c913_l931_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 932 fn c914_l932_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c914_l932_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c914_l932_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c914_l932_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c914_l932_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 933 fn c915_l933_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c915_l933_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c915_l933_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c915_l933_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c915_l933_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 934 fn c916_l934_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c916_l934_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c916_l934_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c916_l934_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c916_l934_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 935 fn c917_l935_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c917_l935_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c917_l935_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c917_l935_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c917_l935_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 936 fn c918_l936_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c918_l936_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c918_l936_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c918_l936_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c918_l936_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 937 fn c919_l937_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c919_l937_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c919_l937_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c919_l937_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c919_l937_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 938 fn c920_l938_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c920_l938_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c920_l938_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c920_l938_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c920_l938_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -8439,7 +15436,13 @@ fn c924_l942_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 943 fn c925_l943_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c925_l943_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -8447,7 +15450,13 @@ fn c925_l943_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 944 fn c926_l944_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c926_l944_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8455,7 +15464,13 @@ fn c926_l944_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 945 fn c927_l945_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c927_l945_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8463,7 +15478,13 @@ fn c927_l945_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 946 fn c928_l946_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c928_l946_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -8471,32 +15492,76 @@ fn c928_l946_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 947 fn c929_l947_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c929_l947_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000005877472f32) + ))) + ); result.map(|_| ()) } // Line 948 fn c930_l948_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c930_l948_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000005877472f32) + ))) + ); result.map(|_| ()) } // Line 949 fn c931_l949_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c931_l949_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000005877472f32) + ))) + ); result.map(|_| ()) } // Line 950 fn c932_l950_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c932_l950_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000005877472f32) + ))) + ); result.map(|_| ()) } @@ -8599,39 +15664,86 @@ fn c944_l962_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 963 fn c945_l963_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c945_l963_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (170141170000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 964 fn c946_l964_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c946_l964_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-170141170000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 965 fn c947_l965_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c947_l965_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-170141170000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 966 fn c948_l966_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c948_l966_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (170141170000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 967 fn c949_l967_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c949_l967_action_invoke"); - let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -8647,7 +15759,10 @@ fn c950_l968_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 969 fn c951_l969_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c951_l969_action_invoke"); - let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -8662,89 +15777,173 @@ fn c952_l970_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 971 fn c953_l971_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c953_l971_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c953_l971_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c953_l971_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c953_l971_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 972 fn c954_l972_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c954_l972_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c954_l972_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c954_l972_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c954_l972_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 973 fn c955_l973_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c955_l973_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c955_l973_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c955_l973_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c955_l973_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 974 fn c956_l974_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c956_l974_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c956_l974_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c956_l974_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c956_l974_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 975 fn c957_l975_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c957_l975_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c957_l975_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c957_l975_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c957_l975_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 976 fn c958_l976_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c958_l976_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c958_l976_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c958_l976_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c958_l976_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 977 fn c959_l977_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c959_l977_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c959_l977_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c959_l977_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c959_l977_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 978 fn c960_l978_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c960_l978_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c960_l978_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c960_l978_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c960_l978_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -8783,64 +15982,152 @@ fn c964_l982_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 983 fn c965_l983_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c965_l983_action_invoke"); - let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 984 fn c966_l984_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c966_l984_action_invoke"); - let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 985 fn c967_l985_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c967_l985_action_invoke"); - let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 986 fn c968_l986_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c968_l986_action_invoke"); - let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 987 fn c969_l987_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c969_l987_action_invoke"); - let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 988 fn c970_l988_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c970_l988_action_invoke"); - let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 989 fn c971_l989_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c971_l989_action_invoke"); - let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 990 fn c972_l990_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c972_l990_action_invoke"); - let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } @@ -8943,39 +16230,86 @@ fn c984_l1002_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1003 fn c985_l1003_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c985_l1003_action_invoke"); - let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1004 fn c986_l1004_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c986_l1004_action_invoke"); - let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1005 fn c987_l1005_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c987_l1005_action_invoke"); - let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1006 fn c988_l1006_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c988_l1006_action_invoke"); - let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1007 fn c989_l1007_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c989_l1007_action_invoke"); - let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -8991,7 +16325,10 @@ fn c990_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1009 fn c991_l1009_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c991_l1009_action_invoke"); - let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9006,89 +16343,173 @@ fn c992_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1011 fn c993_l1011_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c993_l1011_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c993_l1011_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c993_l1011_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c993_l1011_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1012 fn c994_l1012_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c994_l1012_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c994_l1012_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c994_l1012_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c994_l1012_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1013 fn c995_l1013_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c995_l1013_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c995_l1013_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c995_l1013_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c995_l1013_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1014 fn c996_l1014_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c996_l1014_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c996_l1014_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c996_l1014_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c996_l1014_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1015 fn c997_l1015_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c997_l1015_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c997_l1015_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c997_l1015_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c997_l1015_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1016 fn c998_l1016_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c998_l1016_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c998_l1016_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c998_l1016_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c998_l1016_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1017 fn c999_l1017_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c999_l1017_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c999_l1017_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c999_l1017_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c999_l1017_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1018 fn c1000_l1018_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1000_l1018_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1000_l1018_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1000_l1018_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c1000_l1018_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -9127,64 +16548,152 @@ fn c1004_l1022_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1023 fn c1005_l1023_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1005_l1023_action_invoke"); - let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000008f32) + ))) + ); result.map(|_| ()) } // Line 1024 fn c1006_l1024_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1006_l1024_action_invoke"); - let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000008f32) + ))) + ); result.map(|_| ()) } // Line 1025 fn c1007_l1025_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1007_l1025_action_invoke"); - let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000008f32) + ))) + ); result.map(|_| ()) } // Line 1026 fn c1008_l1026_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1008_l1026_action_invoke"); - let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000008f32) + ))) + ); result.map(|_| ()) } // Line 1027 fn c1009_l1027_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1009_l1027_action_invoke"); - let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.00000000000000000000000000000000000007385849f32) + ))) + ); result.map(|_| ()) } // Line 1028 fn c1010_l1028_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1010_l1028_action_invoke"); - let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.00000000000000000000000000000000000007385849f32) + ))) + ); result.map(|_| ()) } // Line 1029 fn c1011_l1029_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1011_l1029_action_invoke"); - let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.00000000000000000000000000000000000007385849f32) + ))) + ); result.map(|_| ()) } // Line 1030 fn c1012_l1030_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1012_l1030_action_invoke"); - let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.00000000000000000000000000000000000007385849f32) + ))) + ); result.map(|_| ()) } @@ -9255,7 +16764,10 @@ fn c1020_l1038_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1039 fn c1021_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1021_l1039_action_invoke"); - let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "mul", + &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((39.47842f32))))); result.map(|_| ()) } @@ -9263,7 +16775,10 @@ fn c1021_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1040 fn c1022_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1022_l1040_action_invoke"); - let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "mul", + &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-39.47842f32))))); result.map(|_| ()) } @@ -9271,7 +16786,10 @@ fn c1022_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1041 fn c1023_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1023_l1041_action_invoke"); - let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "mul", + &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-39.47842f32))))); result.map(|_| ()) } @@ -9279,7 +16797,10 @@ fn c1023_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1042 fn c1024_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1024_l1042_action_invoke"); - let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "mul", + &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((39.47842f32))))); result.map(|_| ()) } @@ -9287,7 +16808,13 @@ fn c1024_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1043 fn c1025_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1025_l1043_action_invoke"); - let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9295,7 +16822,13 @@ fn c1025_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1044 fn c1026_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1026_l1044_action_invoke"); - let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9303,7 +16836,13 @@ fn c1026_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1045 fn c1027_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1027_l1045_action_invoke"); - let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9311,7 +16850,13 @@ fn c1027_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1046 fn c1028_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1028_l1046_action_invoke"); - let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9319,7 +16864,10 @@ fn c1028_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1047 fn c1029_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1029_l1047_action_invoke"); - let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9327,7 +16875,10 @@ fn c1029_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1048 fn c1030_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1030_l1048_action_invoke"); - let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "mul", + &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9335,7 +16886,10 @@ fn c1030_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1049 fn c1031_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1031_l1049_action_invoke"); - let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9343,103 +16897,208 @@ fn c1031_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1050 fn c1032_l1050_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1032_l1050_action_invoke"); - let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "mul", + &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 1051 fn c1033_l1051_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1033_l1051_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1033_l1051_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1033_l1051_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1033_l1051_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1052 fn c1034_l1052_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1034_l1052_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1034_l1052_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1034_l1052_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1034_l1052_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1053 fn c1035_l1053_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1035_l1053_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1035_l1053_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1035_l1053_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1035_l1053_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1054 fn c1036_l1054_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1036_l1054_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1036_l1054_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1036_l1054_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1036_l1054_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1055 fn c1037_l1055_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1037_l1055_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1037_l1055_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1037_l1055_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1037_l1055_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1056 fn c1038_l1056_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1038_l1056_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1038_l1056_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1038_l1056_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1038_l1056_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1057 fn c1039_l1057_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1039_l1057_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1039_l1057_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1039_l1057_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1039_l1057_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1058 fn c1040_l1058_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1040_l1058_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1040_l1058_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1040_l1058_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1040_l1058_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1059 fn c1041_l1059_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1041_l1059_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -9447,7 +17106,13 @@ fn c1041_l1059_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1060 fn c1042_l1060_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1042_l1060_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -9455,7 +17120,13 @@ fn c1042_l1060_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1061 fn c1043_l1061_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1043_l1061_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -9463,7 +17134,13 @@ fn c1043_l1061_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1062 fn c1044_l1062_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1044_l1062_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -9471,7 +17148,13 @@ fn c1044_l1062_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1063 fn c1045_l1063_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1045_l1063_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32))))); result.map(|_| ()) } @@ -9479,7 +17162,13 @@ fn c1045_l1063_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1064 fn c1046_l1064_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1046_l1064_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32))))); result.map(|_| ()) } @@ -9487,7 +17176,13 @@ fn c1046_l1064_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1065 fn c1047_l1065_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1047_l1065_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32))))); result.map(|_| ()) } @@ -9495,7 +17190,13 @@ fn c1047_l1065_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1066 fn c1048_l1066_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1048_l1066_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32))))); result.map(|_| ()) } @@ -9503,7 +17204,13 @@ fn c1048_l1066_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1067 fn c1049_l1067_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1049_l1067_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((3.9999998f32))))); result.map(|_| ()) } @@ -9511,7 +17218,13 @@ fn c1049_l1067_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1068 fn c1050_l1068_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1050_l1068_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32))))); result.map(|_| ()) } @@ -9519,7 +17232,13 @@ fn c1050_l1068_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1069 fn c1051_l1069_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1051_l1069_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32))))); result.map(|_| ()) } @@ -9527,7 +17246,13 @@ fn c1051_l1069_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1070 fn c1052_l1070_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1052_l1070_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((3.9999998f32))))); result.map(|_| ()) } @@ -9535,71 +17260,165 @@ fn c1052_l1070_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1071 fn c1053_l1071_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1053_l1071_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (170141170000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1072 fn c1054_l1072_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1054_l1072_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-170141170000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1073 fn c1055_l1073_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1055_l1073_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-170141170000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1074 fn c1056_l1074_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1056_l1074_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (170141170000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1075 fn c1057_l1075_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1057_l1075_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1076 fn c1058_l1076_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1058_l1076_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1077 fn c1059_l1077_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1059_l1077_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1078 fn c1060_l1078_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1060_l1078_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1079 fn c1061_l1079_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1061_l1079_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9607,7 +17426,13 @@ fn c1061_l1079_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1080 fn c1062_l1080_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1062_l1080_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9615,7 +17440,13 @@ fn c1062_l1080_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1081 fn c1063_l1081_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1063_l1081_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9623,7 +17454,13 @@ fn c1063_l1081_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1082 fn c1064_l1082_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1064_l1082_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9631,7 +17468,13 @@ fn c1064_l1082_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1083 fn c1065_l1083_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1065_l1083_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9639,7 +17482,13 @@ fn c1065_l1083_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1084 fn c1066_l1084_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1066_l1084_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9647,7 +17496,13 @@ fn c1066_l1084_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1085 fn c1067_l1085_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1067_l1085_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9655,7 +17510,13 @@ fn c1067_l1085_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1086 fn c1068_l1086_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1068_l1086_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9663,7 +17524,13 @@ fn c1068_l1086_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1087 fn c1069_l1087_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1069_l1087_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9671,7 +17538,13 @@ fn c1069_l1087_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1088 fn c1070_l1088_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1070_l1088_action_invoke"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9679,7 +17552,13 @@ fn c1070_l1088_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1089 fn c1071_l1089_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1071_l1089_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9687,147 +17566,285 @@ fn c1071_l1089_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1090 fn c1072_l1090_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1072_l1090_action_invoke"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 1091 fn c1073_l1091_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1073_l1091_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1073_l1091_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1073_l1091_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1073_l1091_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1092 fn c1074_l1092_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1074_l1092_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1074_l1092_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1074_l1092_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1074_l1092_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1093 fn c1075_l1093_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1075_l1093_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1075_l1093_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1075_l1093_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1075_l1093_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1094 fn c1076_l1094_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1076_l1094_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1076_l1094_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1076_l1094_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1076_l1094_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1095 fn c1077_l1095_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1077_l1095_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1077_l1095_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1077_l1095_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1077_l1095_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1096 fn c1078_l1096_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1078_l1096_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1078_l1096_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1078_l1096_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1078_l1096_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1097 fn c1079_l1097_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1079_l1097_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1079_l1097_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1079_l1097_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1079_l1097_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1098 fn c1080_l1098_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1080_l1098_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1080_l1098_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1080_l1098_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1080_l1098_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1099 fn c1081_l1099_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1081_l1099_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1081_l1099_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1081_l1099_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))], + ) + .unwrap() + .expect("Missing result in c1081_l1099_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1100 fn c1082_l1100_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1082_l1100_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1082_l1100_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1082_l1100_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c1082_l1100_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1101 fn c1083_l1101_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1083_l1101_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1083_l1101_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1083_l1101_assert_return_canonical_nan" + ); + let result = instance + .call("mul", &[Value::F32(f32::INFINITY), Value::F32((-0.0f32))]) + .unwrap() + .expect("Missing result in c1083_l1101_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1102 fn c1084_l1102_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1084_l1102_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1084_l1102_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1084_l1102_assert_return_canonical_nan" + ); + let result = instance + .call("mul", &[Value::F32(f32::INFINITY), Value::F32((0.0f32))]) + .unwrap() + .expect("Missing result in c1084_l1102_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1103 fn c1085_l1103_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1085_l1103_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9835,7 +17852,13 @@ fn c1085_l1103_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1104 fn c1086_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1086_l1104_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9843,7 +17866,13 @@ fn c1086_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1105 fn c1087_l1105_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1087_l1105_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9851,7 +17880,13 @@ fn c1087_l1105_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1106 fn c1088_l1106_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1088_l1106_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "mul", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9859,7 +17894,13 @@ fn c1088_l1106_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1107 fn c1089_l1107_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1089_l1107_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9867,7 +17908,13 @@ fn c1089_l1107_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1108 fn c1090_l1108_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1090_l1108_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9875,7 +17922,13 @@ fn c1090_l1108_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1109 fn c1091_l1109_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1091_l1109_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9883,7 +17936,13 @@ fn c1091_l1109_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1110 fn c1092_l1110_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1092_l1110_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "mul", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9891,7 +17950,10 @@ fn c1092_l1110_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1111 fn c1093_l1111_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1093_l1111_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]); + let result = instance.call( + "mul", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9899,7 +17961,10 @@ fn c1093_l1111_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1112 fn c1094_l1112_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1094_l1112_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))]); + let result = instance.call( + "mul", + &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9923,7 +17988,10 @@ fn c1096_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1115 fn c1097_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1097_l1115_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]); + let result = instance.call( + "mul", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9931,7 +17999,10 @@ fn c1097_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1116 fn c1098_l1116_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1098_l1116_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))]); + let result = instance.call( + "mul", + &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9955,7 +18026,10 @@ fn c1100_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1119 fn c1101_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1101_l1119_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "mul", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9963,7 +18037,10 @@ fn c1101_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1120 fn c1102_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1102_l1120_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "mul", + &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9971,7 +18048,10 @@ fn c1102_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1121 fn c1103_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1103_l1121_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "mul", + &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9979,7 +18059,10 @@ fn c1103_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1122 fn c1104_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1104_l1122_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "mul", + &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9987,7 +18070,13 @@ fn c1104_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1123 fn c1105_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1105_l1123_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9995,7 +18084,13 @@ fn c1105_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1124 fn c1106_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1106_l1124_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -10003,7 +18098,13 @@ fn c1106_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1125 fn c1107_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1107_l1125_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32(f32::INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -10011,7 +18112,13 @@ fn c1107_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1126 fn c1108_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1108_l1126_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "mul", + &[ + Value::F32(f32::INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -10019,7 +18126,10 @@ fn c1108_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1127 fn c1109_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1109_l1127_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -10027,7 +18137,10 @@ fn c1109_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1128 fn c1110_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1110_l1128_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "mul", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -10035,7 +18148,10 @@ fn c1110_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1129 fn c1111_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1111_l1129_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -10043,1027 +18159,2080 @@ fn c1111_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1130 fn c1112_l1130_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1112_l1130_action_invoke"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "mul", + &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 1131 fn c1113_l1131_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1113_l1131_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1113_l1131_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1113_l1131_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1113_l1131_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1132 fn c1114_l1132_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1114_l1132_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1114_l1132_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1114_l1132_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1114_l1132_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1133 fn c1115_l1133_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1115_l1133_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1115_l1133_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1115_l1133_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1115_l1133_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1134 fn c1116_l1134_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1116_l1134_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1116_l1134_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1116_l1134_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1116_l1134_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1135 fn c1117_l1135_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1117_l1135_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1117_l1135_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1117_l1135_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1117_l1135_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1136 fn c1118_l1136_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1118_l1136_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1118_l1136_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1118_l1136_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1118_l1136_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1137 fn c1119_l1137_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1119_l1137_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1119_l1137_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1119_l1137_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1119_l1137_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1138 fn c1120_l1138_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1120_l1138_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1120_l1138_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1120_l1138_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1120_l1138_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1139 fn c1121_l1139_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1121_l1139_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1121_l1139_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1121_l1139_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1121_l1139_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1140 fn c1122_l1140_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1122_l1140_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1122_l1140_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1122_l1140_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1122_l1140_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1141 fn c1123_l1141_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1123_l1141_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1123_l1141_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1123_l1141_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c1123_l1141_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1142 fn c1124_l1142_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1124_l1142_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1124_l1142_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1124_l1142_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c1124_l1142_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1143 fn c1125_l1143_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1125_l1143_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1125_l1143_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1125_l1143_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1125_l1143_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1144 fn c1126_l1144_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1126_l1144_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1126_l1144_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1126_l1144_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1126_l1144_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1145 fn c1127_l1145_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1127_l1145_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1127_l1145_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1127_l1145_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c1127_l1145_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1146 fn c1128_l1146_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1128_l1146_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1128_l1146_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1128_l1146_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c1128_l1146_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1147 fn c1129_l1147_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1129_l1147_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1129_l1147_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1129_l1147_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1129_l1147_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1148 fn c1130_l1148_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1130_l1148_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1130_l1148_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1130_l1148_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1130_l1148_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1149 fn c1131_l1149_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1131_l1149_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1131_l1149_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1131_l1149_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1131_l1149_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1150 fn c1132_l1150_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1132_l1150_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1132_l1150_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1132_l1150_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1132_l1150_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1151 fn c1133_l1151_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1133_l1151_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1133_l1151_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1133_l1151_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1133_l1151_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1152 fn c1134_l1152_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1134_l1152_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1134_l1152_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1134_l1152_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1134_l1152_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1153 fn c1135_l1153_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1135_l1153_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1135_l1153_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1135_l1153_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1135_l1153_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1154 fn c1136_l1154_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1136_l1154_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1136_l1154_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1136_l1154_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1136_l1154_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1155 fn c1137_l1155_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1137_l1155_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1137_l1155_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1137_l1155_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1137_l1155_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1156 fn c1138_l1156_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1138_l1156_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1138_l1156_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1138_l1156_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1138_l1156_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1157 fn c1139_l1157_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1139_l1157_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1139_l1157_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1139_l1157_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1139_l1157_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1158 fn c1140_l1158_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1140_l1158_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1140_l1158_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1140_l1158_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1140_l1158_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1159 fn c1141_l1159_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1141_l1159_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1141_l1159_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1141_l1159_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1141_l1159_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1160 fn c1142_l1160_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1142_l1160_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1142_l1160_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1142_l1160_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1142_l1160_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1161 fn c1143_l1161_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1143_l1161_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1143_l1161_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1143_l1161_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1143_l1161_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1162 fn c1144_l1162_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1144_l1162_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1144_l1162_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1144_l1162_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1144_l1162_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1163 fn c1145_l1163_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1145_l1163_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1145_l1163_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1145_l1163_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c1145_l1163_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1164 fn c1146_l1164_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1146_l1164_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1146_l1164_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1146_l1164_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c1146_l1164_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1165 fn c1147_l1165_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1147_l1165_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1147_l1165_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1147_l1165_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c1147_l1165_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1166 fn c1148_l1166_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1148_l1166_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1148_l1166_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1148_l1166_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c1148_l1166_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1167 fn c1149_l1167_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1149_l1167_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1149_l1167_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1149_l1167_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c1149_l1167_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1168 fn c1150_l1168_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1150_l1168_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1150_l1168_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1150_l1168_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c1150_l1168_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1169 fn c1151_l1169_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1151_l1169_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1151_l1169_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1151_l1169_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c1151_l1169_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1170 fn c1152_l1170_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1152_l1170_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1152_l1170_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1152_l1170_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c1152_l1170_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1171 fn c1153_l1171_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1153_l1171_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1153_l1171_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1153_l1171_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1153_l1171_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1172 fn c1154_l1172_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1154_l1172_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1154_l1172_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1154_l1172_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1154_l1172_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1173 fn c1155_l1173_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1155_l1173_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1155_l1173_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1155_l1173_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c1155_l1173_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1174 fn c1156_l1174_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1156_l1174_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1156_l1174_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1156_l1174_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c1156_l1174_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1175 fn c1157_l1175_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1157_l1175_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1157_l1175_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1157_l1175_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1157_l1175_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1176 fn c1158_l1176_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1158_l1176_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1158_l1176_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1158_l1176_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1158_l1176_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1177 fn c1159_l1177_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1159_l1177_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1159_l1177_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1159_l1177_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c1159_l1177_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1178 fn c1160_l1178_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1160_l1178_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1160_l1178_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1160_l1178_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c1160_l1178_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1179 fn c1161_l1179_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1161_l1179_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1161_l1179_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1161_l1179_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1161_l1179_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1180 fn c1162_l1180_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1162_l1180_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1162_l1180_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1162_l1180_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1162_l1180_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1181 fn c1163_l1181_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1163_l1181_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1163_l1181_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1163_l1181_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1163_l1181_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1182 fn c1164_l1182_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1164_l1182_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1164_l1182_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1164_l1182_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1164_l1182_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1183 fn c1165_l1183_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1165_l1183_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1165_l1183_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1165_l1183_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1165_l1183_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1184 fn c1166_l1184_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1166_l1184_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1166_l1184_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1166_l1184_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1166_l1184_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1185 fn c1167_l1185_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1167_l1185_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1167_l1185_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1167_l1185_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1167_l1185_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1186 fn c1168_l1186_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1168_l1186_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1168_l1186_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1168_l1186_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1168_l1186_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1187 fn c1169_l1187_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1169_l1187_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1169_l1187_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1169_l1187_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1169_l1187_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1188 fn c1170_l1188_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1170_l1188_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1170_l1188_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1170_l1188_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1170_l1188_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1189 fn c1171_l1189_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1171_l1189_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1171_l1189_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1171_l1189_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1171_l1189_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1190 fn c1172_l1190_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1172_l1190_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1172_l1190_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1172_l1190_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1172_l1190_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1191 fn c1173_l1191_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1173_l1191_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1173_l1191_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1173_l1191_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1173_l1191_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1192 fn c1174_l1192_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1174_l1192_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1174_l1192_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1174_l1192_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1174_l1192_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1193 fn c1175_l1193_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1175_l1193_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1175_l1193_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1175_l1193_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1175_l1193_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1194 fn c1176_l1194_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1176_l1194_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1176_l1194_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1176_l1194_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1176_l1194_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1195 fn c1177_l1195_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1177_l1195_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1177_l1195_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1177_l1195_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1177_l1195_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1196 fn c1178_l1196_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1178_l1196_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1178_l1196_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1178_l1196_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1178_l1196_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1197 fn c1179_l1197_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1179_l1197_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1179_l1197_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1179_l1197_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1179_l1197_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1198 fn c1180_l1198_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1180_l1198_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1180_l1198_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1180_l1198_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1180_l1198_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1199 fn c1181_l1199_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1181_l1199_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1181_l1199_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1181_l1199_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1181_l1199_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1200 fn c1182_l1200_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1182_l1200_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1182_l1200_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1182_l1200_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1182_l1200_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1201 fn c1183_l1201_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1183_l1201_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1183_l1201_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1183_l1201_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1183_l1201_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1202 fn c1184_l1202_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1184_l1202_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1184_l1202_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1184_l1202_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1184_l1202_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1203 fn c1185_l1203_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1185_l1203_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1185_l1203_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1185_l1203_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1185_l1203_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1204 fn c1186_l1204_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1186_l1204_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1186_l1204_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1186_l1204_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1186_l1204_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1205 fn c1187_l1205_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1187_l1205_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1187_l1205_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1187_l1205_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1187_l1205_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1206 fn c1188_l1206_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1188_l1206_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1188_l1206_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1188_l1206_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1188_l1206_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1207 fn c1189_l1207_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1189_l1207_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1189_l1207_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1189_l1207_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1189_l1207_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1208 fn c1190_l1208_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1190_l1208_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1190_l1208_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1190_l1208_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1190_l1208_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1209 fn c1191_l1209_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1191_l1209_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1191_l1209_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1191_l1209_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1191_l1209_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1210 fn c1192_l1210_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1192_l1210_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1192_l1210_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1192_l1210_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1192_l1210_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1211 fn c1193_l1211_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1193_l1211_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1193_l1211_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1193_l1211_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1193_l1211_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1212 fn c1194_l1212_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1194_l1212_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1194_l1212_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1194_l1212_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1194_l1212_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1213 fn c1195_l1213_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1195_l1213_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1195_l1213_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1195_l1213_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1195_l1213_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1214 fn c1196_l1214_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1196_l1214_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1196_l1214_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1196_l1214_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1196_l1214_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1215 fn c1197_l1215_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1197_l1215_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1197_l1215_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1197_l1215_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1197_l1215_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1216 fn c1198_l1216_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1198_l1216_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1198_l1216_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1198_l1216_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1198_l1216_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1217 fn c1199_l1217_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1199_l1217_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1199_l1217_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1199_l1217_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1199_l1217_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1218 fn c1200_l1218_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1200_l1218_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1200_l1218_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1200_l1218_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1200_l1218_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1219 fn c1201_l1219_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1201_l1219_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1201_l1219_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1201_l1219_assert_return_canonical_nan" + ); + let result = instance + .call("div", &[Value::F32((-0.0f32)), Value::F32((-0.0f32))]) + .unwrap() + .expect("Missing result in c1201_l1219_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1220 fn c1202_l1220_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1202_l1220_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1202_l1220_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1202_l1220_assert_return_canonical_nan" + ); + let result = instance + .call("div", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]) + .unwrap() + .expect("Missing result in c1202_l1220_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1221 fn c1203_l1221_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1203_l1221_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1203_l1221_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1203_l1221_assert_return_canonical_nan" + ); + let result = instance + .call("div", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]) + .unwrap() + .expect("Missing result in c1203_l1221_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1222 fn c1204_l1222_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1204_l1222_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1204_l1222_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1204_l1222_assert_return_canonical_nan" + ); + let result = instance + .call("div", &[Value::F32((0.0f32)), Value::F32((0.0f32))]) + .unwrap() + .expect("Missing result in c1204_l1222_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1223 fn c1205_l1223_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1205_l1223_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11071,7 +20240,13 @@ fn c1205_l1223_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1224 fn c1206_l1224_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1206_l1224_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11079,7 +20254,13 @@ fn c1206_l1224_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1225 fn c1207_l1225_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1207_l1225_action_invoke"); - let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11087,7 +20268,13 @@ fn c1207_l1225_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1226 fn c1208_l1226_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1208_l1226_action_invoke"); - let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11095,7 +20282,13 @@ fn c1208_l1226_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1227 fn c1209_l1227_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1209_l1227_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11103,7 +20296,13 @@ fn c1209_l1227_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1228 fn c1210_l1228_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1210_l1228_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11111,7 +20310,13 @@ fn c1210_l1228_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1229 fn c1211_l1229_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1211_l1229_action_invoke"); - let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11119,7 +20324,13 @@ fn c1211_l1229_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1230 fn c1212_l1230_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1212_l1230_action_invoke"); - let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11223,7 +20434,13 @@ fn c1224_l1242_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1243 fn c1225_l1243_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1225_l1243_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11231,7 +20448,13 @@ fn c1225_l1243_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1244 fn c1226_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1226_l1244_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11239,7 +20462,13 @@ fn c1226_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1245 fn c1227_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1227_l1245_action_invoke"); - let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11247,7 +20476,13 @@ fn c1227_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1246 fn c1228_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1228_l1246_action_invoke"); - let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11255,7 +20490,10 @@ fn c1228_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1247 fn c1229_l1247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1229_l1247_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "div", + &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11271,7 +20509,10 @@ fn c1230_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1249 fn c1231_l1249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1231_l1249_action_invoke"); - let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "div", + &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11286,96 +20527,186 @@ fn c1232_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1251 fn c1233_l1251_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1233_l1251_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1233_l1251_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1233_l1251_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1233_l1251_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1252 fn c1234_l1252_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1234_l1252_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1234_l1252_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1234_l1252_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1234_l1252_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1253 fn c1235_l1253_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1235_l1253_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1235_l1253_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1235_l1253_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1235_l1253_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1254 fn c1236_l1254_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1236_l1254_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1236_l1254_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1236_l1254_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1236_l1254_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1255 fn c1237_l1255_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1237_l1255_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1237_l1255_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1237_l1255_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c1237_l1255_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1256 fn c1238_l1256_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1238_l1256_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1238_l1256_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1238_l1256_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c1238_l1256_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1257 fn c1239_l1257_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1239_l1257_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1239_l1257_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1239_l1257_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c1239_l1257_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1258 fn c1240_l1258_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1240_l1258_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1240_l1258_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1240_l1258_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c1240_l1258_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1259 fn c1241_l1259_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1241_l1259_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -11383,7 +20714,13 @@ fn c1241_l1259_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1260 fn c1242_l1260_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1242_l1260_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -11391,7 +20728,13 @@ fn c1242_l1260_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1261 fn c1243_l1261_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1243_l1261_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -11399,7 +20742,13 @@ fn c1243_l1261_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1262 fn c1244_l1262_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1244_l1262_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -11407,7 +20756,13 @@ fn c1244_l1262_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1263 fn c1245_l1263_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1245_l1263_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -11415,7 +20770,13 @@ fn c1245_l1263_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1264 fn c1246_l1264_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1246_l1264_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -11423,7 +20784,13 @@ fn c1246_l1264_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1265 fn c1247_l1265_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1247_l1265_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -11431,7 +20798,13 @@ fn c1247_l1265_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1266 fn c1248_l1266_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1248_l1266_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -11439,7 +20812,13 @@ fn c1248_l1266_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1267 fn c1249_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1249_l1267_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000011920929f32))))); result.map(|_| ()) } @@ -11447,7 +20826,13 @@ fn c1249_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1268 fn c1250_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1250_l1268_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.00000011920929f32))))); result.map(|_| ()) } @@ -11455,7 +20840,13 @@ fn c1250_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1269 fn c1251_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1251_l1269_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.00000011920929f32))))); result.map(|_| ()) } @@ -11463,7 +20854,13 @@ fn c1251_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1270 fn c1252_l1270_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1252_l1270_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000011920929f32))))); result.map(|_| ()) } @@ -11471,71 +20868,165 @@ fn c1252_l1270_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1271 fn c1253_l1271_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1253_l1271_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000003f32) + ))) + ); result.map(|_| ()) } // Line 1272 fn c1254_l1272_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1254_l1272_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000003f32) + ))) + ); result.map(|_| ()) } // Line 1273 fn c1255_l1273_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1255_l1273_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32))))); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000003f32) + ))) + ); result.map(|_| ()) } // Line 1274 fn c1256_l1274_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1256_l1274_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32))))); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000003f32) + ))) + ); result.map(|_| ()) } // Line 1275 fn c1257_l1275_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1257_l1275_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1276 fn c1258_l1276_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1258_l1276_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1277 fn c1259_l1277_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1259_l1277_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1278 fn c1260_l1278_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1260_l1278_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1279 fn c1261_l1279_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1261_l1279_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11543,7 +21034,13 @@ fn c1261_l1279_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1280 fn c1262_l1280_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1262_l1280_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11551,7 +21048,13 @@ fn c1262_l1280_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1281 fn c1263_l1281_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1263_l1281_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11559,7 +21062,13 @@ fn c1263_l1281_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1282 fn c1264_l1282_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1264_l1282_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11567,7 +21076,13 @@ fn c1264_l1282_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1283 fn c1265_l1283_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1265_l1283_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11575,7 +21090,13 @@ fn c1265_l1283_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1284 fn c1266_l1284_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1266_l1284_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11583,7 +21104,13 @@ fn c1266_l1284_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1285 fn c1267_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1267_l1285_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11591,7 +21118,13 @@ fn c1267_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1286 fn c1268_l1286_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1268_l1286_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11599,7 +21132,13 @@ fn c1268_l1286_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1287 fn c1269_l1287_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1269_l1287_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11607,7 +21146,13 @@ fn c1269_l1287_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1288 fn c1270_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1270_l1288_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11615,7 +21160,13 @@ fn c1270_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1289 fn c1271_l1289_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1271_l1289_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11623,103 +21174,211 @@ fn c1271_l1289_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1290 fn c1272_l1290_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1272_l1290_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } // Line 1291 fn c1273_l1291_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1273_l1291_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1273_l1291_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1273_l1291_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1273_l1291_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1292 fn c1274_l1292_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1274_l1292_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1274_l1292_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1274_l1292_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1274_l1292_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1293 fn c1275_l1293_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1275_l1293_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1275_l1293_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1275_l1293_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1275_l1293_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1294 fn c1276_l1294_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1276_l1294_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1276_l1294_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1276_l1294_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1276_l1294_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1295 fn c1277_l1295_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1277_l1295_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1277_l1295_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1277_l1295_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1277_l1295_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1296 fn c1278_l1296_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1278_l1296_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1278_l1296_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1278_l1296_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1278_l1296_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1297 fn c1279_l1297_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1279_l1297_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1279_l1297_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1279_l1297_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1279_l1297_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1298 fn c1280_l1298_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1280_l1298_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1280_l1298_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1280_l1298_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1280_l1298_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1299 fn c1281_l1299_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1281_l1299_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -11727,7 +21386,13 @@ fn c1281_l1299_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1300 fn c1282_l1300_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1282_l1300_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -11735,7 +21400,13 @@ fn c1282_l1300_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1301 fn c1283_l1301_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1283_l1301_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -11743,7 +21414,13 @@ fn c1283_l1301_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1302 fn c1284_l1302_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1284_l1302_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -11751,7 +21428,13 @@ fn c1284_l1302_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1303 fn c1285_l1303_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1285_l1303_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((8388608.0f32))))); result.map(|_| ()) } @@ -11759,7 +21442,13 @@ fn c1285_l1303_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1304 fn c1286_l1304_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1286_l1304_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-8388608.0f32))))); result.map(|_| ()) } @@ -11767,7 +21456,13 @@ fn c1286_l1304_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1305 fn c1287_l1305_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1287_l1305_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-8388608.0f32))))); result.map(|_| ()) } @@ -11775,7 +21470,13 @@ fn c1287_l1305_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1306 fn c1288_l1306_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1288_l1306_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((8388608.0f32))))); result.map(|_| ()) } @@ -11783,7 +21484,13 @@ fn c1288_l1306_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1307 fn c1289_l1307_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1289_l1307_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -11791,7 +21498,13 @@ fn c1289_l1307_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1308 fn c1290_l1308_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1290_l1308_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -11799,7 +21512,13 @@ fn c1290_l1308_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1309 fn c1291_l1309_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1291_l1309_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -11807,7 +21526,13 @@ fn c1291_l1309_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1310 fn c1292_l1310_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1292_l1310_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -11815,103 +21540,241 @@ fn c1292_l1310_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1311 fn c1293_l1311_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1293_l1311_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000023509887f32) + ))) + ); result.map(|_| ()) } // Line 1312 fn c1294_l1312_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1294_l1312_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000023509887f32) + ))) + ); result.map(|_| ()) } // Line 1313 fn c1295_l1313_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1295_l1313_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32))))); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000023509887f32) + ))) + ); result.map(|_| ()) } // Line 1314 fn c1296_l1314_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1296_l1314_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32))))); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000023509887f32) + ))) + ); result.map(|_| ()) } // Line 1315 fn c1297_l1315_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1297_l1315_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1316 fn c1298_l1316_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1298_l1316_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1317 fn c1299_l1317_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1299_l1317_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1318 fn c1300_l1318_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1300_l1318_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1319 fn c1301_l1319_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1301_l1319_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001870857f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000001870857f32) + ))) + ); result.map(|_| ()) } // Line 1320 fn c1302_l1320_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1302_l1320_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001870857f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000001870857f32) + ))) + ); result.map(|_| ()) } // Line 1321 fn c1303_l1321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1303_l1321_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001870857f32))))); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000001870857f32) + ))) + ); result.map(|_| ()) } // Line 1322 fn c1304_l1322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1304_l1322_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001870857f32))))); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000001870857f32) + ))) + ); result.map(|_| ()) } // Line 1323 fn c1305_l1323_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1305_l1323_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11919,7 +21782,13 @@ fn c1305_l1323_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1324 fn c1306_l1324_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1306_l1324_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11927,7 +21796,13 @@ fn c1306_l1324_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1325 fn c1307_l1325_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1307_l1325_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11935,7 +21810,13 @@ fn c1307_l1325_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1326 fn c1308_l1326_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1308_l1326_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11943,7 +21824,13 @@ fn c1308_l1326_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1327 fn c1309_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1309_l1327_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11951,7 +21838,13 @@ fn c1309_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1328 fn c1310_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1310_l1328_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11959,7 +21852,13 @@ fn c1310_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1329 fn c1311_l1329_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1311_l1329_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -11967,96 +21866,198 @@ fn c1311_l1329_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1330 fn c1312_l1330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1312_l1330_action_invoke"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } // Line 1331 fn c1313_l1331_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1313_l1331_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1313_l1331_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1313_l1331_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1313_l1331_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1332 fn c1314_l1332_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1314_l1332_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1314_l1332_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1314_l1332_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1314_l1332_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1333 fn c1315_l1333_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1315_l1333_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1315_l1333_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1315_l1333_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1315_l1333_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1334 fn c1316_l1334_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1316_l1334_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1316_l1334_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1316_l1334_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1316_l1334_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1335 fn c1317_l1335_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1317_l1335_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1317_l1335_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1317_l1335_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1317_l1335_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1336 fn c1318_l1336_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1318_l1336_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1318_l1336_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1318_l1336_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1318_l1336_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1337 fn c1319_l1337_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1319_l1337_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1319_l1337_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1319_l1337_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1319_l1337_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1338 fn c1320_l1338_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1320_l1338_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1320_l1338_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1320_l1338_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1320_l1338_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -12095,7 +22096,13 @@ fn c1324_l1342_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1343 fn c1325_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1325_l1343_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -12103,7 +22110,13 @@ fn c1325_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1344 fn c1326_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1326_l1344_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -12111,7 +22124,13 @@ fn c1326_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1345 fn c1327_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1327_l1345_action_invoke"); - let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -12119,7 +22138,13 @@ fn c1327_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1346 fn c1328_l1346_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1328_l1346_action_invoke"); - let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -12127,32 +22152,76 @@ fn c1328_l1346_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1347 fn c1329_l1347_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1329_l1347_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((42535296000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (42535296000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1348 fn c1330_l1348_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1330_l1348_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-42535296000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-42535296000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1349 fn c1331_l1349_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1331_l1349_action_invoke"); - let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-42535296000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-42535296000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1350 fn c1332_l1350_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1332_l1350_action_invoke"); - let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((42535296000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (42535296000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -12255,39 +22324,86 @@ fn c1344_l1362_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1363 fn c1345_l1363_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1345_l1363_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001469368f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000001469368f32) + ))) + ); result.map(|_| ()) } // Line 1364 fn c1346_l1364_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1346_l1364_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001469368f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000001469368f32) + ))) + ); result.map(|_| ()) } // Line 1365 fn c1347_l1365_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1347_l1365_action_invoke"); - let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001469368f32))))); + let result = instance.call( + "div", + &[ + Value::F32((0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000001469368f32) + ))) + ); result.map(|_| ()) } // Line 1366 fn c1348_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1348_l1366_action_invoke"); - let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001469368f32))))); + let result = instance.call( + "div", + &[ + Value::F32((0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000001469368f32) + ))) + ); result.map(|_| ()) } // Line 1367 fn c1349_l1367_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1349_l1367_action_invoke"); - let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "div", + &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -12303,7 +22419,10 @@ fn c1350_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1369 fn c1351_l1369_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1351_l1369_action_invoke"); - let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "div", + &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -12318,89 +22437,173 @@ fn c1352_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1371 fn c1353_l1371_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1353_l1371_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1353_l1371_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1353_l1371_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1353_l1371_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1372 fn c1354_l1372_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1354_l1372_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1354_l1372_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1354_l1372_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1354_l1372_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1373 fn c1355_l1373_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1355_l1373_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1355_l1373_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1355_l1373_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1355_l1373_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1374 fn c1356_l1374_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1356_l1374_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1356_l1374_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1356_l1374_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1356_l1374_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1375 fn c1357_l1375_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1357_l1375_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1357_l1375_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1357_l1375_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c1357_l1375_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1376 fn c1358_l1376_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1358_l1376_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1358_l1376_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1358_l1376_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c1358_l1376_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1377 fn c1359_l1377_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1359_l1377_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1359_l1377_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1359_l1377_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c1359_l1377_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1378 fn c1360_l1378_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1360_l1378_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1360_l1378_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1360_l1378_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c1360_l1378_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -12439,7 +22642,13 @@ fn c1364_l1382_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1383 fn c1365_l1383_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1365_l1383_action_invoke"); - let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -12447,7 +22656,13 @@ fn c1365_l1383_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1384 fn c1366_l1384_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1366_l1384_action_invoke"); - let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -12455,7 +22670,13 @@ fn c1366_l1384_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1385 fn c1367_l1385_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1367_l1385_action_invoke"); - let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -12463,7 +22684,13 @@ fn c1367_l1385_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1386 fn c1368_l1386_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1368_l1386_action_invoke"); - let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -12471,32 +22698,76 @@ fn c1368_l1386_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1387 fn c1369_l1387_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1369_l1387_action_invoke"); - let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((85070590000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (85070590000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1388 fn c1370_l1388_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1370_l1388_action_invoke"); - let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-85070590000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-85070590000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1389 fn c1371_l1389_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1371_l1389_action_invoke"); - let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-85070590000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-85070590000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1390 fn c1372_l1390_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1372_l1390_action_invoke"); - let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((85070590000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (85070590000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -12599,39 +22870,86 @@ fn c1384_l1402_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1403 fn c1385_l1403_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1385_l1403_action_invoke"); - let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000002938736f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000002938736f32) + ))) + ); result.map(|_| ()) } // Line 1404 fn c1386_l1404_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1386_l1404_action_invoke"); - let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000002938736f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000002938736f32) + ))) + ); result.map(|_| ()) } // Line 1405 fn c1387_l1405_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1387_l1405_action_invoke"); - let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000002938736f32))))); + let result = instance.call( + "div", + &[ + Value::F32((1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000002938736f32) + ))) + ); result.map(|_| ()) } // Line 1406 fn c1388_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1388_l1406_action_invoke"); - let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000002938736f32))))); + let result = instance.call( + "div", + &[ + Value::F32((1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000002938736f32) + ))) + ); result.map(|_| ()) } // Line 1407 fn c1389_l1407_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1389_l1407_action_invoke"); - let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "div", + &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -12647,7 +22965,10 @@ fn c1390_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1409 fn c1391_l1409_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1391_l1409_action_invoke"); - let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "div", + &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -12662,89 +22983,173 @@ fn c1392_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1411 fn c1393_l1411_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1393_l1411_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1393_l1411_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1393_l1411_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1393_l1411_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1412 fn c1394_l1412_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1394_l1412_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1394_l1412_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1394_l1412_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1394_l1412_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1413 fn c1395_l1413_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1395_l1413_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1395_l1413_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1395_l1413_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1395_l1413_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1414 fn c1396_l1414_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1396_l1414_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1396_l1414_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1396_l1414_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1396_l1414_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1415 fn c1397_l1415_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1397_l1415_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1397_l1415_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1397_l1415_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c1397_l1415_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1416 fn c1398_l1416_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1398_l1416_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1398_l1416_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1398_l1416_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c1398_l1416_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1417 fn c1399_l1417_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1399_l1417_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1399_l1417_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1399_l1417_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c1399_l1417_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1418 fn c1400_l1418_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1400_l1418_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1400_l1418_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1400_l1418_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c1400_l1418_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -12783,7 +23188,13 @@ fn c1404_l1422_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1423 fn c1405_l1423_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1405_l1423_action_invoke"); - let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -12791,7 +23202,13 @@ fn c1405_l1423_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1424 fn c1406_l1424_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1406_l1424_action_invoke"); - let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -12799,7 +23216,13 @@ fn c1406_l1424_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1425 fn c1407_l1425_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1407_l1425_action_invoke"); - let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -12807,7 +23230,13 @@ fn c1407_l1425_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1426 fn c1408_l1426_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1408_l1426_action_invoke"); - let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -12815,7 +23244,13 @@ fn c1408_l1426_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1427 fn c1409_l1427_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1409_l1427_action_invoke"); - let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -12823,7 +23258,13 @@ fn c1409_l1427_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1428 fn c1410_l1428_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1410_l1428_action_invoke"); - let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -12831,7 +23272,13 @@ fn c1410_l1428_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1429 fn c1411_l1429_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1411_l1429_action_invoke"); - let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -12839,7 +23286,13 @@ fn c1411_l1429_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1430 fn c1412_l1430_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1412_l1430_action_invoke"); - let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -12911,7 +23364,10 @@ fn c1420_l1438_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1439 fn c1421_l1439_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1421_l1439_action_invoke"); - let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "div", + &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -12919,7 +23375,10 @@ fn c1421_l1439_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1440 fn c1422_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1422_l1440_action_invoke"); - let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "div", + &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -12927,7 +23386,10 @@ fn c1422_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1441 fn c1423_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1423_l1441_action_invoke"); - let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "div", + &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -12935,7 +23397,10 @@ fn c1423_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1442 fn c1424_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1424_l1442_action_invoke"); - let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "div", + &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -12943,39 +23408,86 @@ fn c1424_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1443 fn c1425_l1443_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1425_l1443_action_invoke"); - let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000018464624f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000018464624f32) + ))) + ); result.map(|_| ()) } // Line 1444 fn c1426_l1444_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1426_l1444_action_invoke"); - let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000018464624f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000018464624f32) + ))) + ); result.map(|_| ()) } // Line 1445 fn c1427_l1445_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1427_l1445_action_invoke"); - let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000018464624f32))))); + let result = instance.call( + "div", + &[ + Value::F32((6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000018464624f32) + ))) + ); result.map(|_| ()) } // Line 1446 fn c1428_l1446_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1428_l1446_action_invoke"); - let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000018464624f32))))); + let result = instance.call( + "div", + &[ + Value::F32((6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000018464624f32) + ))) + ); result.map(|_| ()) } // Line 1447 fn c1429_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1429_l1447_action_invoke"); - let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "div", + &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -12983,7 +23495,10 @@ fn c1429_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1448 fn c1430_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1430_l1448_action_invoke"); - let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "div", + &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -12991,7 +23506,10 @@ fn c1430_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1449 fn c1431_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1431_l1449_action_invoke"); - let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "div", + &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -12999,103 +23517,208 @@ fn c1431_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1450 fn c1432_l1450_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1432_l1450_action_invoke"); - let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "div", + &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } // Line 1451 fn c1433_l1451_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1433_l1451_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1433_l1451_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1433_l1451_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1433_l1451_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1452 fn c1434_l1452_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1434_l1452_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1434_l1452_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1434_l1452_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1434_l1452_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1453 fn c1435_l1453_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1435_l1453_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1435_l1453_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1435_l1453_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1435_l1453_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1454 fn c1436_l1454_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1436_l1454_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1436_l1454_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1436_l1454_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1436_l1454_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1455 fn c1437_l1455_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1437_l1455_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1437_l1455_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1437_l1455_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1437_l1455_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1456 fn c1438_l1456_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1438_l1456_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1438_l1456_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1438_l1456_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1438_l1456_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1457 fn c1439_l1457_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1439_l1457_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1439_l1457_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1439_l1457_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1439_l1457_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1458 fn c1440_l1458_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1440_l1458_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1440_l1458_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1440_l1458_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1440_l1458_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1459 fn c1441_l1459_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1441_l1459_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13103,7 +23726,13 @@ fn c1441_l1459_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1460 fn c1442_l1460_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1442_l1460_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13111,7 +23740,13 @@ fn c1442_l1460_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1461 fn c1443_l1461_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1443_l1461_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13119,7 +23754,13 @@ fn c1443_l1461_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1462 fn c1444_l1462_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1444_l1462_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13127,7 +23768,13 @@ fn c1444_l1462_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1463 fn c1445_l1463_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1445_l1463_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13135,7 +23782,13 @@ fn c1445_l1463_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1464 fn c1446_l1464_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1446_l1464_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13143,7 +23796,13 @@ fn c1446_l1464_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1465 fn c1447_l1465_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1447_l1465_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13151,7 +23810,13 @@ fn c1447_l1465_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1466 fn c1448_l1466_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1448_l1466_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13159,7 +23824,13 @@ fn c1448_l1466_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1467 fn c1449_l1467_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1449_l1467_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13167,7 +23838,13 @@ fn c1449_l1467_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1468 fn c1450_l1468_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1450_l1468_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13175,7 +23852,13 @@ fn c1450_l1468_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1469 fn c1451_l1469_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1451_l1469_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13183,7 +23866,13 @@ fn c1451_l1469_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1470 fn c1452_l1470_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1452_l1470_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13191,7 +23880,13 @@ fn c1452_l1470_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1471 fn c1453_l1471_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1453_l1471_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13199,7 +23894,13 @@ fn c1453_l1471_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1472 fn c1454_l1472_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1454_l1472_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13207,7 +23908,13 @@ fn c1454_l1472_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1473 fn c1455_l1473_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1455_l1473_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13215,7 +23922,13 @@ fn c1455_l1473_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1474 fn c1456_l1474_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1456_l1474_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13223,71 +23936,165 @@ fn c1456_l1474_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1475 fn c1457_l1475_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1457_l1475_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1476 fn c1458_l1476_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1458_l1476_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1477 fn c1459_l1477_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1459_l1477_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1478 fn c1460_l1478_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1460_l1478_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1479 fn c1461_l1479_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1461_l1479_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((54157613000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (54157613000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1480 fn c1462_l1480_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1462_l1480_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-54157613000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-54157613000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1481 fn c1463_l1481_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1463_l1481_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-54157613000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-54157613000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1482 fn c1464_l1482_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1464_l1482_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((54157613000000000000000000000000000000.0f32))))); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (54157613000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1483 fn c1465_l1483_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1465_l1483_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -13295,7 +24102,13 @@ fn c1465_l1483_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1484 fn c1466_l1484_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1466_l1484_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -13303,7 +24116,13 @@ fn c1466_l1484_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1485 fn c1467_l1485_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1467_l1485_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -13311,7 +24130,13 @@ fn c1467_l1485_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1486 fn c1468_l1486_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1468_l1486_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -13319,7 +24144,13 @@ fn c1468_l1486_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1487 fn c1469_l1487_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1469_l1487_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -13327,7 +24158,13 @@ fn c1469_l1487_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1488 fn c1470_l1488_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1470_l1488_action_invoke"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -13335,7 +24172,13 @@ fn c1470_l1488_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1489 fn c1471_l1489_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1471_l1489_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -13343,103 +24186,208 @@ fn c1471_l1489_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1490 fn c1472_l1490_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1472_l1490_action_invoke"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } // Line 1491 fn c1473_l1491_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1473_l1491_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1473_l1491_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1473_l1491_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1473_l1491_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1492 fn c1474_l1492_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1474_l1492_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1474_l1492_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1474_l1492_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1474_l1492_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1493 fn c1475_l1493_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1475_l1493_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1475_l1493_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1475_l1493_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1475_l1493_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1494 fn c1476_l1494_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1476_l1494_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1476_l1494_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1476_l1494_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1476_l1494_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1495 fn c1477_l1495_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1477_l1495_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1477_l1495_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1477_l1495_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1477_l1495_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1496 fn c1478_l1496_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1478_l1496_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1478_l1496_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1478_l1496_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1478_l1496_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1497 fn c1479_l1497_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1479_l1497_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1479_l1497_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1479_l1497_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1479_l1497_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1498 fn c1480_l1498_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1480_l1498_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1480_l1498_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1480_l1498_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1480_l1498_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1499 fn c1481_l1499_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1481_l1499_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]); + let result = instance.call( + "div", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13447,7 +24395,10 @@ fn c1481_l1499_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1500 fn c1482_l1500_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1482_l1500_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))]); + let result = instance.call( + "div", + &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13471,7 +24422,13 @@ fn c1484_l1502_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1503 fn c1485_l1503_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1485_l1503_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13479,7 +24436,13 @@ fn c1485_l1503_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1504 fn c1486_l1504_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1486_l1504_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13487,7 +24450,13 @@ fn c1486_l1504_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1505 fn c1487_l1505_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1487_l1505_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13495,7 +24464,13 @@ fn c1487_l1505_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1506 fn c1488_l1506_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1488_l1506_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "div", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13503,7 +24478,13 @@ fn c1488_l1506_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1507 fn c1489_l1507_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1489_l1507_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13511,7 +24492,13 @@ fn c1489_l1507_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1508 fn c1490_l1508_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1490_l1508_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13519,7 +24506,13 @@ fn c1490_l1508_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1509 fn c1491_l1509_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1491_l1509_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13527,7 +24520,13 @@ fn c1491_l1509_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1510 fn c1492_l1510_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1492_l1510_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "div", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13535,7 +24534,10 @@ fn c1492_l1510_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1511 fn c1493_l1511_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1493_l1511_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]); + let result = instance.call( + "div", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13543,7 +24545,10 @@ fn c1493_l1511_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1512 fn c1494_l1512_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1494_l1512_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))]); + let result = instance.call( + "div", + &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13567,7 +24572,10 @@ fn c1496_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1515 fn c1497_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1497_l1515_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]); + let result = instance.call( + "div", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13575,7 +24583,10 @@ fn c1497_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1516 fn c1498_l1516_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1498_l1516_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))]); + let result = instance.call( + "div", + &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13599,7 +24610,10 @@ fn c1500_l1518_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1519 fn c1501_l1519_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1501_l1519_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "div", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13607,7 +24621,10 @@ fn c1501_l1519_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1520 fn c1502_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1502_l1520_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "div", + &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13615,7 +24632,10 @@ fn c1502_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1521 fn c1503_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1503_l1521_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "div", + &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13623,7 +24643,10 @@ fn c1503_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1522 fn c1504_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1504_l1522_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "div", + &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13631,7 +24654,13 @@ fn c1504_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1523 fn c1505_l1523_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1505_l1523_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -13639,7 +24668,13 @@ fn c1505_l1523_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1524 fn c1506_l1524_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1506_l1524_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13647,7 +24682,13 @@ fn c1506_l1524_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1525 fn c1507_l1525_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1507_l1525_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32(f32::INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -13655,1020 +24696,2082 @@ fn c1507_l1525_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1526 fn c1508_l1526_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1508_l1526_action_invoke"); - let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "div", + &[ + Value::F32(f32::INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 1527 fn c1509_l1527_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1509_l1527_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1509_l1527_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1509_l1527_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)], + ) + .unwrap() + .expect("Missing result in c1509_l1527_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1528 fn c1510_l1528_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1510_l1528_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1510_l1528_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1510_l1528_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)], + ) + .unwrap() + .expect("Missing result in c1510_l1528_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1529 fn c1511_l1529_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1511_l1529_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1511_l1529_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1511_l1529_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)], + ) + .unwrap() + .expect("Missing result in c1511_l1529_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1530 fn c1512_l1530_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1512_l1530_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1512_l1530_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1512_l1530_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)], + ) + .unwrap() + .expect("Missing result in c1512_l1530_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1531 fn c1513_l1531_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1513_l1531_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1513_l1531_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1513_l1531_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1513_l1531_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1532 fn c1514_l1532_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1514_l1532_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1514_l1532_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1514_l1532_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1514_l1532_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1533 fn c1515_l1533_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1515_l1533_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1515_l1533_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1515_l1533_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1515_l1533_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1534 fn c1516_l1534_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1516_l1534_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1516_l1534_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1516_l1534_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1516_l1534_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1535 fn c1517_l1535_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1517_l1535_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1517_l1535_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1517_l1535_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1517_l1535_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1536 fn c1518_l1536_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1518_l1536_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1518_l1536_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1518_l1536_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1518_l1536_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1537 fn c1519_l1537_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1519_l1537_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1519_l1537_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1519_l1537_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1519_l1537_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1538 fn c1520_l1538_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1520_l1538_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1520_l1538_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1520_l1538_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1520_l1538_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1539 fn c1521_l1539_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1521_l1539_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1521_l1539_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1521_l1539_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1521_l1539_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1540 fn c1522_l1540_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1522_l1540_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1522_l1540_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1522_l1540_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1522_l1540_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1541 fn c1523_l1541_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1523_l1541_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1523_l1541_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1523_l1541_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c1523_l1541_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1542 fn c1524_l1542_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1524_l1542_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1524_l1542_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1524_l1542_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c1524_l1542_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1543 fn c1525_l1543_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1525_l1543_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1525_l1543_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1525_l1543_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1525_l1543_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1544 fn c1526_l1544_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1526_l1544_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1526_l1544_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1526_l1544_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1526_l1544_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1545 fn c1527_l1545_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1527_l1545_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1527_l1545_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1527_l1545_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c1527_l1545_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1546 fn c1528_l1546_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1528_l1546_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1528_l1546_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1528_l1546_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c1528_l1546_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1547 fn c1529_l1547_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1529_l1547_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1529_l1547_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1529_l1547_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1529_l1547_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1548 fn c1530_l1548_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1530_l1548_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1530_l1548_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1530_l1548_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1530_l1548_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1549 fn c1531_l1549_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1531_l1549_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1531_l1549_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1531_l1549_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1531_l1549_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1550 fn c1532_l1550_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1532_l1550_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1532_l1550_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1532_l1550_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1532_l1550_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1551 fn c1533_l1551_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1533_l1551_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1533_l1551_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1533_l1551_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1533_l1551_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1552 fn c1534_l1552_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1534_l1552_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1534_l1552_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1534_l1552_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1534_l1552_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1553 fn c1535_l1553_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1535_l1553_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1535_l1553_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1535_l1553_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1535_l1553_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1554 fn c1536_l1554_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1536_l1554_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1536_l1554_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1536_l1554_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1536_l1554_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1555 fn c1537_l1555_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1537_l1555_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1537_l1555_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1537_l1555_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1537_l1555_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1556 fn c1538_l1556_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1538_l1556_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1538_l1556_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1538_l1556_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1538_l1556_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1557 fn c1539_l1557_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1539_l1557_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1539_l1557_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1539_l1557_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1539_l1557_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1558 fn c1540_l1558_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1540_l1558_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1540_l1558_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1540_l1558_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1540_l1558_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1559 fn c1541_l1559_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1541_l1559_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1541_l1559_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1541_l1559_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1541_l1559_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1560 fn c1542_l1560_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1542_l1560_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1542_l1560_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1542_l1560_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1542_l1560_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1561 fn c1543_l1561_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1543_l1561_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1543_l1561_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1543_l1561_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1543_l1561_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1562 fn c1544_l1562_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1544_l1562_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1544_l1562_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1544_l1562_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1544_l1562_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1563 fn c1545_l1563_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1545_l1563_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1545_l1563_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1545_l1563_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c1545_l1563_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1564 fn c1546_l1564_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1546_l1564_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1546_l1564_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1546_l1564_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c1546_l1564_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1565 fn c1547_l1565_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1547_l1565_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1547_l1565_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1547_l1565_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c1547_l1565_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1566 fn c1548_l1566_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1548_l1566_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1548_l1566_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1548_l1566_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c1548_l1566_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1567 fn c1549_l1567_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1549_l1567_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1549_l1567_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1549_l1567_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c1549_l1567_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1568 fn c1550_l1568_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1550_l1568_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1550_l1568_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1550_l1568_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c1550_l1568_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1569 fn c1551_l1569_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1551_l1569_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1551_l1569_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1551_l1569_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c1551_l1569_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1570 fn c1552_l1570_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1552_l1570_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1552_l1570_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1552_l1570_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c1552_l1570_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1571 fn c1553_l1571_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1553_l1571_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1553_l1571_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1553_l1571_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1553_l1571_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1572 fn c1554_l1572_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1554_l1572_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1554_l1572_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1554_l1572_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1554_l1572_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1573 fn c1555_l1573_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1555_l1573_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1555_l1573_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1555_l1573_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c1555_l1573_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1574 fn c1556_l1574_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1556_l1574_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1556_l1574_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1556_l1574_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c1556_l1574_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1575 fn c1557_l1575_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1557_l1575_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1557_l1575_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1557_l1575_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1557_l1575_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1576 fn c1558_l1576_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1558_l1576_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1558_l1576_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1558_l1576_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1558_l1576_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1577 fn c1559_l1577_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1559_l1577_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1559_l1577_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1559_l1577_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c1559_l1577_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1578 fn c1560_l1578_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1560_l1578_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1560_l1578_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1560_l1578_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c1560_l1578_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1579 fn c1561_l1579_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1561_l1579_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1561_l1579_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1561_l1579_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1561_l1579_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1580 fn c1562_l1580_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1562_l1580_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1562_l1580_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1562_l1580_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1562_l1580_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1581 fn c1563_l1581_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1563_l1581_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1563_l1581_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1563_l1581_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1563_l1581_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1582 fn c1564_l1582_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1564_l1582_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1564_l1582_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1564_l1582_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1564_l1582_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1583 fn c1565_l1583_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1565_l1583_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1565_l1583_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1565_l1583_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1565_l1583_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1584 fn c1566_l1584_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1566_l1584_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1566_l1584_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1566_l1584_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1566_l1584_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1585 fn c1567_l1585_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1567_l1585_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1567_l1585_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1567_l1585_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1567_l1585_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1586 fn c1568_l1586_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1568_l1586_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1568_l1586_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1568_l1586_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1568_l1586_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1587 fn c1569_l1587_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1569_l1587_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1569_l1587_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1569_l1587_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1569_l1587_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1588 fn c1570_l1588_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1570_l1588_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1570_l1588_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1570_l1588_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1570_l1588_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1589 fn c1571_l1589_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1571_l1589_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1571_l1589_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1571_l1589_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1571_l1589_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1590 fn c1572_l1590_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1572_l1590_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1572_l1590_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1572_l1590_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1572_l1590_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1591 fn c1573_l1591_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1573_l1591_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1573_l1591_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1573_l1591_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1573_l1591_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1592 fn c1574_l1592_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1574_l1592_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1574_l1592_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1574_l1592_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1574_l1592_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1593 fn c1575_l1593_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1575_l1593_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1575_l1593_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1575_l1593_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1575_l1593_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1594 fn c1576_l1594_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1576_l1594_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1576_l1594_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1576_l1594_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1576_l1594_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1595 fn c1577_l1595_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1577_l1595_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1577_l1595_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1577_l1595_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1577_l1595_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1596 fn c1578_l1596_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1578_l1596_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1578_l1596_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1578_l1596_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1578_l1596_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1597 fn c1579_l1597_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1579_l1597_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1579_l1597_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1579_l1597_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1579_l1597_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1598 fn c1580_l1598_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1580_l1598_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1580_l1598_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1580_l1598_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1580_l1598_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1599 fn c1581_l1599_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1581_l1599_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1581_l1599_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1581_l1599_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1581_l1599_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1600 fn c1582_l1600_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1582_l1600_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1582_l1600_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1582_l1600_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1582_l1600_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1601 fn c1583_l1601_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1583_l1601_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1583_l1601_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1583_l1601_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1583_l1601_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1602 fn c1584_l1602_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1584_l1602_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1584_l1602_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1584_l1602_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1584_l1602_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1603 fn c1585_l1603_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1585_l1603_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1585_l1603_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1585_l1603_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1585_l1603_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1604 fn c1586_l1604_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1586_l1604_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1586_l1604_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1586_l1604_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1586_l1604_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1605 fn c1587_l1605_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1587_l1605_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1587_l1605_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1587_l1605_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1587_l1605_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1606 fn c1588_l1606_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1588_l1606_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1588_l1606_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1588_l1606_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1588_l1606_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1607 fn c1589_l1607_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1589_l1607_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1589_l1607_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1589_l1607_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1589_l1607_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1608 fn c1590_l1608_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1590_l1608_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1590_l1608_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1590_l1608_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1590_l1608_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1609 fn c1591_l1609_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1591_l1609_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1591_l1609_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1591_l1609_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1591_l1609_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1610 fn c1592_l1610_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1592_l1610_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1592_l1610_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1592_l1610_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1592_l1610_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1611 fn c1593_l1611_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1593_l1611_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1593_l1611_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1593_l1611_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1593_l1611_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1612 fn c1594_l1612_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1594_l1612_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1594_l1612_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1594_l1612_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1594_l1612_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1613 fn c1595_l1613_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1595_l1613_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1595_l1613_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1595_l1613_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1595_l1613_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1614 fn c1596_l1614_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1596_l1614_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1596_l1614_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1596_l1614_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1596_l1614_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1615 fn c1597_l1615_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1597_l1615_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1597_l1615_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1597_l1615_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1597_l1615_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1616 fn c1598_l1616_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1598_l1616_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1598_l1616_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1598_l1616_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1598_l1616_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1617 fn c1599_l1617_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1599_l1617_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1599_l1617_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1599_l1617_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1599_l1617_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1618 fn c1600_l1618_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1600_l1618_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1600_l1618_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1600_l1618_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1600_l1618_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -14707,15 +26810,32 @@ fn c1604_l1622_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1623 fn c1605_l1623_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1605_l1623_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1624 fn c1606_l1624_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1606_l1624_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -14723,15 +26843,32 @@ fn c1606_l1624_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1625 fn c1607_l1625_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1607_l1625_action_invoke"); - let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1626 fn c1608_l1626_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1608_l1626_action_invoke"); - let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "min", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -14739,15 +26876,32 @@ fn c1608_l1626_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1627 fn c1609_l1627_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1609_l1627_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1628 fn c1610_l1628_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1610_l1628_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -14755,15 +26909,32 @@ fn c1610_l1628_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1629 fn c1611_l1629_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1611_l1629_action_invoke"); - let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1630 fn c1612_l1630_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1612_l1630_action_invoke"); - let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "min", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -14867,15 +27038,32 @@ fn c1624_l1642_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1643 fn c1625_l1643_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1625_l1643_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1644 fn c1626_l1644_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1626_l1644_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -14883,15 +27071,32 @@ fn c1626_l1644_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1645 fn c1627_l1645_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1627_l1645_action_invoke"); - let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1646 fn c1628_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1628_l1646_action_invoke"); - let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -14899,7 +27104,10 @@ fn c1628_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1647 fn c1629_l1647_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1629_l1647_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -14915,7 +27123,10 @@ fn c1630_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1649 fn c1631_l1649_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1631_l1649_action_invoke"); - let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -14930,112 +27141,224 @@ fn c1632_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1651 fn c1633_l1651_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1633_l1651_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1633_l1651_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1633_l1651_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1633_l1651_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1652 fn c1634_l1652_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1634_l1652_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1634_l1652_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1634_l1652_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1634_l1652_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1653 fn c1635_l1653_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1635_l1653_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1635_l1653_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1635_l1653_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1635_l1653_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1654 fn c1636_l1654_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1636_l1654_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1636_l1654_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1636_l1654_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1636_l1654_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1655 fn c1637_l1655_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1637_l1655_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1637_l1655_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1637_l1655_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c1637_l1655_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1656 fn c1638_l1656_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1638_l1656_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1638_l1656_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1638_l1656_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c1638_l1656_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1657 fn c1639_l1657_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1639_l1657_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1639_l1657_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1639_l1657_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c1639_l1657_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1658 fn c1640_l1658_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1640_l1658_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1640_l1658_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1640_l1658_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c1640_l1658_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1659 fn c1641_l1659_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1641_l1659_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1660 fn c1642_l1660_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1642_l1660_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1661 fn c1643_l1661_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1643_l1661_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -15043,7 +27366,13 @@ fn c1643_l1661_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1662 fn c1644_l1662_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1644_l1662_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -15051,71 +27380,165 @@ fn c1644_l1662_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1663 fn c1645_l1663_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1645_l1663_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1664 fn c1646_l1664_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1646_l1664_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1665 fn c1647_l1665_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1647_l1665_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1666 fn c1648_l1666_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1648_l1666_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1667 fn c1649_l1667_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1649_l1667_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1668 fn c1650_l1668_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1650_l1668_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1669 fn c1651_l1669_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1651_l1669_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1670 fn c1652_l1670_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1652_l1670_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1671 fn c1653_l1671_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1653_l1671_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -15123,15 +27546,32 @@ fn c1653_l1671_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1672 fn c1654_l1672_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1654_l1672_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1673 fn c1655_l1673_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1655_l1673_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -15139,15 +27579,32 @@ fn c1655_l1673_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1674 fn c1656_l1674_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1656_l1674_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1675 fn c1657_l1675_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1657_l1675_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -15155,15 +27612,32 @@ fn c1657_l1675_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1676 fn c1658_l1676_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1658_l1676_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1677 fn c1659_l1677_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1659_l1677_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -15171,15 +27645,32 @@ fn c1659_l1677_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1678 fn c1660_l1678_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1660_l1678_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1679 fn c1661_l1679_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1661_l1679_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -15187,15 +27678,32 @@ fn c1661_l1679_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1680 fn c1662_l1680_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1662_l1680_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1681 fn c1663_l1681_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1663_l1681_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -15203,47 +27711,108 @@ fn c1663_l1681_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1682 fn c1664_l1682_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1664_l1682_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1683 fn c1665_l1683_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1665_l1683_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1684 fn c1666_l1684_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1666_l1684_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1685 fn c1667_l1685_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1667_l1685_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1686 fn c1668_l1686_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1668_l1686_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1687 fn c1669_l1687_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1669_l1687_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -15251,15 +27820,32 @@ fn c1669_l1687_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1688 fn c1670_l1688_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1670_l1688_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1689 fn c1671_l1689_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1671_l1689_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -15267,119 +27853,254 @@ fn c1671_l1689_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1690 fn c1672_l1690_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1672_l1690_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1691 fn c1673_l1691_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1673_l1691_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1673_l1691_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1673_l1691_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1673_l1691_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1692 fn c1674_l1692_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1674_l1692_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1674_l1692_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1674_l1692_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1674_l1692_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1693 fn c1675_l1693_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1675_l1693_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1675_l1693_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1675_l1693_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1675_l1693_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1694 fn c1676_l1694_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1676_l1694_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1676_l1694_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1676_l1694_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1676_l1694_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1695 fn c1677_l1695_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1677_l1695_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1677_l1695_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1677_l1695_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1677_l1695_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1696 fn c1678_l1696_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1678_l1696_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1678_l1696_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1678_l1696_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1678_l1696_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1697 fn c1679_l1697_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1679_l1697_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1679_l1697_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1679_l1697_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1679_l1697_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1698 fn c1680_l1698_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1680_l1698_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1680_l1698_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1680_l1698_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1680_l1698_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1699 fn c1681_l1699_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1681_l1699_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1700 fn c1682_l1700_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1682_l1700_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1701 fn c1683_l1701_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1683_l1701_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -15387,7 +28108,13 @@ fn c1683_l1701_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1702 fn c1684_l1702_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1684_l1702_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -15395,71 +28122,165 @@ fn c1684_l1702_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1703 fn c1685_l1703_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1685_l1703_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1704 fn c1686_l1704_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1686_l1704_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1705 fn c1687_l1705_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1687_l1705_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1706 fn c1688_l1706_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1688_l1706_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1707 fn c1689_l1707_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1689_l1707_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1708 fn c1690_l1708_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1690_l1708_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1709 fn c1691_l1709_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1691_l1709_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1710 fn c1692_l1710_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1692_l1710_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1711 fn c1693_l1711_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1693_l1711_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -15467,15 +28288,32 @@ fn c1693_l1711_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1712 fn c1694_l1712_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1694_l1712_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1713 fn c1695_l1713_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1695_l1713_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -15483,15 +28321,32 @@ fn c1695_l1713_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1714 fn c1696_l1714_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1696_l1714_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1715 fn c1697_l1715_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1697_l1715_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -15499,15 +28354,32 @@ fn c1697_l1715_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1716 fn c1698_l1716_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1698_l1716_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1717 fn c1699_l1717_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1699_l1717_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -15515,15 +28387,32 @@ fn c1699_l1717_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1718 fn c1700_l1718_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1700_l1718_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1719 fn c1701_l1719_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1701_l1719_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -15531,15 +28420,32 @@ fn c1701_l1719_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1720 fn c1702_l1720_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1702_l1720_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1721 fn c1703_l1721_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1703_l1721_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -15547,47 +28453,108 @@ fn c1703_l1721_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1722 fn c1704_l1722_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1704_l1722_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1723 fn c1705_l1723_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1705_l1723_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1724 fn c1706_l1724_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1706_l1724_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1725 fn c1707_l1725_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1707_l1725_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1726 fn c1708_l1726_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1708_l1726_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1727 fn c1709_l1727_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1709_l1727_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -15595,15 +28562,32 @@ fn c1709_l1727_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1728 fn c1710_l1728_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1710_l1728_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1729 fn c1711_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1711_l1729_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -15611,96 +28595,203 @@ fn c1711_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1730 fn c1712_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1712_l1730_action_invoke"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1731 fn c1713_l1731_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1713_l1731_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1713_l1731_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1713_l1731_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1713_l1731_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1732 fn c1714_l1732_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1714_l1732_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1714_l1732_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1714_l1732_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1714_l1732_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1733 fn c1715_l1733_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1715_l1733_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1715_l1733_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1715_l1733_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1715_l1733_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1734 fn c1716_l1734_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1716_l1734_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1716_l1734_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1716_l1734_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1716_l1734_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1735 fn c1717_l1735_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1717_l1735_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1717_l1735_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1717_l1735_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1717_l1735_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1736 fn c1718_l1736_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1718_l1736_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1718_l1736_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1718_l1736_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1718_l1736_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1737 fn c1719_l1737_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1719_l1737_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1719_l1737_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1719_l1737_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1719_l1737_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1738 fn c1720_l1738_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1720_l1738_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1720_l1738_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1720_l1738_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1720_l1738_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -15739,7 +28830,13 @@ fn c1724_l1742_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1743 fn c1725_l1743_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1725_l1743_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -15747,7 +28844,13 @@ fn c1725_l1743_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1744 fn c1726_l1744_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1726_l1744_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -15755,23 +28858,51 @@ fn c1726_l1744_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1745 fn c1727_l1745_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1727_l1745_action_invoke"); - let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1746 fn c1728_l1746_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1728_l1746_action_invoke"); - let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1747 fn c1729_l1747_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1729_l1747_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -15779,7 +28910,13 @@ fn c1729_l1747_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1748 fn c1730_l1748_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1730_l1748_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -15787,16 +28924,38 @@ fn c1730_l1748_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1749 fn c1731_l1749_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1731_l1749_action_invoke"); - let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1750 fn c1732_l1750_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1732_l1750_action_invoke"); - let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } @@ -15899,15 +29058,32 @@ fn c1744_l1762_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1763 fn c1745_l1763_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1745_l1763_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1764 fn c1746_l1764_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1746_l1764_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -15915,15 +29091,32 @@ fn c1746_l1764_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1765 fn c1747_l1765_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1747_l1765_action_invoke"); - let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1766 fn c1748_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1748_l1766_action_invoke"); - let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -15931,7 +29124,10 @@ fn c1748_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1767 fn c1749_l1767_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1749_l1767_action_invoke"); - let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -15947,7 +29143,10 @@ fn c1750_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1769 fn c1751_l1769_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1751_l1769_action_invoke"); - let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -15962,89 +29161,173 @@ fn c1752_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1771 fn c1753_l1771_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1753_l1771_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1753_l1771_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1753_l1771_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1753_l1771_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1772 fn c1754_l1772_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1754_l1772_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1754_l1772_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1754_l1772_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1754_l1772_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1773 fn c1755_l1773_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1755_l1773_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1755_l1773_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1755_l1773_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1755_l1773_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1774 fn c1756_l1774_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1756_l1774_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1756_l1774_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1756_l1774_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1756_l1774_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1775 fn c1757_l1775_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1757_l1775_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1757_l1775_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1757_l1775_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c1757_l1775_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1776 fn c1758_l1776_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1758_l1776_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1758_l1776_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1758_l1776_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c1758_l1776_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1777 fn c1759_l1777_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1759_l1777_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1759_l1777_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1759_l1777_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c1759_l1777_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1778 fn c1760_l1778_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1760_l1778_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1760_l1778_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1760_l1778_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c1760_l1778_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -16083,7 +29366,13 @@ fn c1764_l1782_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1783 fn c1765_l1783_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1765_l1783_action_invoke"); - let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -16091,7 +29380,13 @@ fn c1765_l1783_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1784 fn c1766_l1784_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1766_l1784_action_invoke"); - let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -16099,23 +29394,51 @@ fn c1766_l1784_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1785 fn c1767_l1785_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1767_l1785_action_invoke"); - let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1786 fn c1768_l1786_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1768_l1786_action_invoke"); - let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1787 fn c1769_l1787_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1769_l1787_action_invoke"); - let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -16123,7 +29446,13 @@ fn c1769_l1787_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1788 fn c1770_l1788_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1770_l1788_action_invoke"); - let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -16131,16 +29460,38 @@ fn c1770_l1788_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1789 fn c1771_l1789_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1771_l1789_action_invoke"); - let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1790 fn c1772_l1790_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1772_l1790_action_invoke"); - let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } @@ -16243,15 +29594,32 @@ fn c1784_l1802_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1803 fn c1785_l1803_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1785_l1803_action_invoke"); - let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1804 fn c1786_l1804_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1786_l1804_action_invoke"); - let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -16259,15 +29627,32 @@ fn c1786_l1804_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1805 fn c1787_l1805_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1787_l1805_action_invoke"); - let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1806 fn c1788_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1788_l1806_action_invoke"); - let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -16275,7 +29660,10 @@ fn c1788_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1807 fn c1789_l1807_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1789_l1807_action_invoke"); - let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -16291,7 +29679,10 @@ fn c1790_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1809 fn c1791_l1809_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1791_l1809_action_invoke"); - let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -16306,89 +29697,173 @@ fn c1792_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1811 fn c1793_l1811_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1793_l1811_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1793_l1811_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1793_l1811_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1793_l1811_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1812 fn c1794_l1812_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1794_l1812_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1794_l1812_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1794_l1812_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1794_l1812_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1813 fn c1795_l1813_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1795_l1813_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1795_l1813_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1795_l1813_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1795_l1813_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1814 fn c1796_l1814_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1796_l1814_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1796_l1814_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1796_l1814_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1796_l1814_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1815 fn c1797_l1815_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1797_l1815_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1797_l1815_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1797_l1815_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c1797_l1815_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1816 fn c1798_l1816_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1798_l1816_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1798_l1816_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1798_l1816_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c1798_l1816_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1817 fn c1799_l1817_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1799_l1817_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1799_l1817_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1799_l1817_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c1799_l1817_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1818 fn c1800_l1818_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1800_l1818_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1800_l1818_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1800_l1818_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c1800_l1818_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -16427,7 +29902,13 @@ fn c1804_l1822_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1823 fn c1805_l1823_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1805_l1823_action_invoke"); - let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -16435,7 +29916,13 @@ fn c1805_l1823_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1824 fn c1806_l1824_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1806_l1824_action_invoke"); - let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -16443,23 +29930,51 @@ fn c1806_l1824_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1825 fn c1807_l1825_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1807_l1825_action_invoke"); - let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1826 fn c1808_l1826_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1808_l1826_action_invoke"); - let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1827 fn c1809_l1827_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1809_l1827_action_invoke"); - let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -16467,7 +29982,13 @@ fn c1809_l1827_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1828 fn c1810_l1828_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1810_l1828_action_invoke"); - let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -16475,16 +29996,38 @@ fn c1810_l1828_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1829 fn c1811_l1829_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1811_l1829_action_invoke"); - let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1830 fn c1812_l1830_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1812_l1830_action_invoke"); - let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } @@ -16555,7 +30098,10 @@ fn c1820_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1839 fn c1821_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1821_l1839_action_invoke"); - let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "min", + &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -16563,7 +30109,10 @@ fn c1821_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1840 fn c1822_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1822_l1840_action_invoke"); - let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "min", + &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -16571,7 +30120,10 @@ fn c1822_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1841 fn c1823_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1823_l1841_action_invoke"); - let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "min", + &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -16579,7 +30131,10 @@ fn c1823_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1842 fn c1824_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1824_l1842_action_invoke"); - let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "min", + &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -16587,15 +30142,32 @@ fn c1824_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1843 fn c1825_l1843_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1825_l1843_action_invoke"); - let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1844 fn c1826_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1826_l1844_action_invoke"); - let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((-6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -16603,15 +30175,32 @@ fn c1826_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1845 fn c1827_l1845_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1827_l1845_action_invoke"); - let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1846 fn c1828_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1828_l1846_action_invoke"); - let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -16619,7 +30208,10 @@ fn c1828_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1847 fn c1829_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1829_l1847_action_invoke"); - let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -16627,7 +30219,10 @@ fn c1829_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1848 fn c1830_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1830_l1848_action_invoke"); - let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "min", + &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -16635,7 +30230,10 @@ fn c1830_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1849 fn c1831_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1831_l1849_action_invoke"); - let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -16643,119 +30241,246 @@ fn c1831_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1850 fn c1832_l1850_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1832_l1850_action_invoke"); - let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "min", + &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } // Line 1851 fn c1833_l1851_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1833_l1851_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1833_l1851_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1833_l1851_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1833_l1851_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1852 fn c1834_l1852_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1834_l1852_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1834_l1852_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1834_l1852_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1834_l1852_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1853 fn c1835_l1853_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1835_l1853_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1835_l1853_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1835_l1853_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1835_l1853_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1854 fn c1836_l1854_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1836_l1854_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1836_l1854_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1836_l1854_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1836_l1854_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1855 fn c1837_l1855_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1837_l1855_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1837_l1855_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1837_l1855_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1837_l1855_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1856 fn c1838_l1856_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1838_l1856_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1838_l1856_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1838_l1856_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1838_l1856_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1857 fn c1839_l1857_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1839_l1857_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1839_l1857_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1839_l1857_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1839_l1857_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1858 fn c1840_l1858_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1840_l1858_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1840_l1858_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1840_l1858_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1840_l1858_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1859 fn c1841_l1859_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1841_l1859_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1860 fn c1842_l1860_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1842_l1860_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1861 fn c1843_l1861_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1843_l1861_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -16763,7 +30488,13 @@ fn c1843_l1861_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1862 fn c1844_l1862_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1844_l1862_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -16771,87 +30502,203 @@ fn c1844_l1862_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1863 fn c1845_l1863_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1845_l1863_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1864 fn c1846_l1864_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1846_l1864_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1865 fn c1847_l1865_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1847_l1865_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1866 fn c1848_l1866_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1848_l1866_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1867 fn c1849_l1867_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1849_l1867_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1868 fn c1850_l1868_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1850_l1868_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1869 fn c1851_l1869_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1851_l1869_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1870 fn c1852_l1870_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1852_l1870_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1871 fn c1853_l1871_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1853_l1871_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1872 fn c1854_l1872_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1854_l1872_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1873 fn c1855_l1873_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1855_l1873_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -16859,7 +30706,13 @@ fn c1855_l1873_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1874 fn c1856_l1874_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1856_l1874_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -16867,23 +30720,51 @@ fn c1856_l1874_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1875 fn c1857_l1875_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1857_l1875_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1876 fn c1858_l1876_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1858_l1876_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1877 fn c1859_l1877_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1859_l1877_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -16891,7 +30772,13 @@ fn c1859_l1877_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1878 fn c1860_l1878_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1860_l1878_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -16899,23 +30786,51 @@ fn c1860_l1878_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1879 fn c1861_l1879_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1861_l1879_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1880 fn c1862_l1880_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1862_l1880_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1881 fn c1863_l1881_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1863_l1881_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -16923,7 +30838,13 @@ fn c1863_l1881_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1882 fn c1864_l1882_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1864_l1882_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -16931,39 +30852,89 @@ fn c1864_l1882_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1883 fn c1865_l1883_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1865_l1883_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1884 fn c1866_l1884_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1866_l1884_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1885 fn c1867_l1885_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1867_l1885_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1886 fn c1868_l1886_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1868_l1886_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1887 fn c1869_l1887_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1869_l1887_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -16971,15 +30942,32 @@ fn c1869_l1887_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1888 fn c1870_l1888_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1870_l1888_action_invoke"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1889 fn c1871_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1871_l1889_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -16987,103 +30975,213 @@ fn c1871_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1890 fn c1872_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1872_l1890_action_invoke"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1891 fn c1873_l1891_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1873_l1891_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1873_l1891_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1873_l1891_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1873_l1891_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1892 fn c1874_l1892_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1874_l1892_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1874_l1892_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1874_l1892_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1874_l1892_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1893 fn c1875_l1893_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1875_l1893_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1875_l1893_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1875_l1893_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1875_l1893_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1894 fn c1876_l1894_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1876_l1894_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1876_l1894_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1876_l1894_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1876_l1894_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1895 fn c1877_l1895_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1877_l1895_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1877_l1895_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1877_l1895_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1877_l1895_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1896 fn c1878_l1896_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1878_l1896_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1878_l1896_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1878_l1896_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1878_l1896_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1897 fn c1879_l1897_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1879_l1897_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1879_l1897_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1879_l1897_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1879_l1897_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1898 fn c1880_l1898_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1880_l1898_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1880_l1898_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1880_l1898_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1880_l1898_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1899 fn c1881_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1881_l1899_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]); + let result = instance.call( + "min", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17091,7 +31189,10 @@ fn c1881_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1900 fn c1882_l1900_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1882_l1900_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))]); + let result = instance.call( + "min", + &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17115,7 +31216,13 @@ fn c1884_l1902_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1903 fn c1885_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1885_l1903_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "min", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17123,7 +31230,13 @@ fn c1885_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1904 fn c1886_l1904_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1886_l1904_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "min", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17131,23 +31244,51 @@ fn c1886_l1904_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1905 fn c1887_l1905_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1887_l1905_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1906 fn c1888_l1906_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1888_l1906_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "min", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 1907 fn c1889_l1907_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1889_l1907_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "min", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17155,7 +31296,13 @@ fn c1889_l1907_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1908 fn c1890_l1908_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1890_l1908_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "min", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17163,23 +31310,48 @@ fn c1890_l1908_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1909 fn c1891_l1909_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1891_l1909_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1910 fn c1892_l1910_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1892_l1910_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "min", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 1911 fn c1893_l1911_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1893_l1911_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]); + let result = instance.call( + "min", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17187,7 +31359,10 @@ fn c1893_l1911_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1912 fn c1894_l1912_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1894_l1912_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))]); + let result = instance.call( + "min", + &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17211,7 +31386,10 @@ fn c1896_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1915 fn c1897_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1897_l1915_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]); + let result = instance.call( + "min", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17219,7 +31397,10 @@ fn c1897_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1916 fn c1898_l1916_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1898_l1916_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))]); + let result = instance.call( + "min", + &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17243,7 +31424,10 @@ fn c1900_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1919 fn c1901_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1901_l1919_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "min", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17251,7 +31435,10 @@ fn c1901_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1920 fn c1902_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1902_l1920_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "min", + &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17259,7 +31446,10 @@ fn c1902_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1921 fn c1903_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1903_l1921_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "min", + &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -17267,7 +31457,10 @@ fn c1903_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1922 fn c1904_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1904_l1922_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "min", + &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -17275,7 +31468,13 @@ fn c1904_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1923 fn c1905_l1923_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1905_l1923_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17283,7 +31482,13 @@ fn c1905_l1923_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1924 fn c1906_l1924_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1906_l1924_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "min", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17291,23 +31496,48 @@ fn c1906_l1924_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1925 fn c1907_l1925_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1907_l1925_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32(f32::INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1926 fn c1908_l1926_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1908_l1926_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "min", + &[ + Value::F32(f32::INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 1927 fn c1909_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1909_l1927_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17315,7 +31545,10 @@ fn c1909_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1928 fn c1910_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1910_l1928_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "min", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17323,7 +31556,10 @@ fn c1910_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1929 fn c1911_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1911_l1929_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -17331,976 +31567,1999 @@ fn c1911_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1930 fn c1912_l1930_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1912_l1930_action_invoke"); - let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "min", + &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 1931 fn c1913_l1931_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1913_l1931_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1913_l1931_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1913_l1931_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1913_l1931_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1932 fn c1914_l1932_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1914_l1932_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1914_l1932_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1914_l1932_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1914_l1932_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1933 fn c1915_l1933_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1915_l1933_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1915_l1933_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1915_l1933_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1915_l1933_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1934 fn c1916_l1934_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1916_l1934_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1916_l1934_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1916_l1934_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1916_l1934_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1935 fn c1917_l1935_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1917_l1935_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1917_l1935_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1917_l1935_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1917_l1935_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1936 fn c1918_l1936_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1918_l1936_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1918_l1936_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1918_l1936_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1918_l1936_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1937 fn c1919_l1937_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1919_l1937_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1919_l1937_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1919_l1937_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1919_l1937_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1938 fn c1920_l1938_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1920_l1938_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1920_l1938_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1920_l1938_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1920_l1938_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1939 fn c1921_l1939_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1921_l1939_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1921_l1939_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1921_l1939_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1921_l1939_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1940 fn c1922_l1940_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1922_l1940_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1922_l1940_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1922_l1940_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1922_l1940_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1941 fn c1923_l1941_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1923_l1941_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1923_l1941_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1923_l1941_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c1923_l1941_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1942 fn c1924_l1942_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1924_l1942_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1924_l1942_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1924_l1942_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c1924_l1942_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1943 fn c1925_l1943_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1925_l1943_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1925_l1943_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1925_l1943_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1925_l1943_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1944 fn c1926_l1944_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1926_l1944_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c1926_l1944_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1926_l1944_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1926_l1944_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1945 fn c1927_l1945_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1927_l1945_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1927_l1945_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1927_l1945_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c1927_l1945_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1946 fn c1928_l1946_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1928_l1946_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c1928_l1946_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1928_l1946_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c1928_l1946_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1947 fn c1929_l1947_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1929_l1947_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1929_l1947_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1929_l1947_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1929_l1947_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1948 fn c1930_l1948_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1930_l1948_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1930_l1948_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1930_l1948_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1930_l1948_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1949 fn c1931_l1949_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1931_l1949_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1931_l1949_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1931_l1949_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1931_l1949_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1950 fn c1932_l1950_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1932_l1950_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1932_l1950_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1932_l1950_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1932_l1950_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1951 fn c1933_l1951_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1933_l1951_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1933_l1951_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1933_l1951_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1933_l1951_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1952 fn c1934_l1952_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1934_l1952_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1934_l1952_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1934_l1952_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1934_l1952_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1953 fn c1935_l1953_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1935_l1953_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1935_l1953_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1935_l1953_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1935_l1953_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1954 fn c1936_l1954_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1936_l1954_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c1936_l1954_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1936_l1954_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c1936_l1954_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1955 fn c1937_l1955_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1937_l1955_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1937_l1955_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1937_l1955_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1937_l1955_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1956 fn c1938_l1956_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1938_l1956_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1938_l1956_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1938_l1956_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1938_l1956_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1957 fn c1939_l1957_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1939_l1957_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1939_l1957_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1939_l1957_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1939_l1957_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1958 fn c1940_l1958_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1940_l1958_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1940_l1958_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1940_l1958_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1940_l1958_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1959 fn c1941_l1959_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1941_l1959_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1941_l1959_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1941_l1959_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1941_l1959_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1960 fn c1942_l1960_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1942_l1960_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1942_l1960_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1942_l1960_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1942_l1960_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1961 fn c1943_l1961_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1943_l1961_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1943_l1961_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1943_l1961_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1943_l1961_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1962 fn c1944_l1962_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1944_l1962_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c1944_l1962_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1944_l1962_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c1944_l1962_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1963 fn c1945_l1963_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1945_l1963_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1945_l1963_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1945_l1963_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c1945_l1963_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1964 fn c1946_l1964_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1946_l1964_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1946_l1964_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1946_l1964_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c1946_l1964_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1965 fn c1947_l1965_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1947_l1965_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1947_l1965_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1947_l1965_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c1947_l1965_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1966 fn c1948_l1966_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1948_l1966_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1948_l1966_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1948_l1966_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c1948_l1966_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1967 fn c1949_l1967_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1949_l1967_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1949_l1967_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1949_l1967_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c1949_l1967_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1968 fn c1950_l1968_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1950_l1968_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c1950_l1968_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1950_l1968_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c1950_l1968_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1969 fn c1951_l1969_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1951_l1969_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1951_l1969_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1951_l1969_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c1951_l1969_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1970 fn c1952_l1970_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1952_l1970_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c1952_l1970_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1952_l1970_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c1952_l1970_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1971 fn c1953_l1971_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1953_l1971_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1953_l1971_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1953_l1971_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1953_l1971_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1972 fn c1954_l1972_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1954_l1972_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1954_l1972_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1954_l1972_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1954_l1972_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1973 fn c1955_l1973_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1955_l1973_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1955_l1973_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1955_l1973_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c1955_l1973_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1974 fn c1956_l1974_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1956_l1974_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1956_l1974_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1956_l1974_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c1956_l1974_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1975 fn c1957_l1975_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1957_l1975_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1957_l1975_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1957_l1975_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1957_l1975_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1976 fn c1958_l1976_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1958_l1976_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c1958_l1976_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1958_l1976_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1958_l1976_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1977 fn c1959_l1977_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1959_l1977_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1959_l1977_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1959_l1977_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c1959_l1977_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1978 fn c1960_l1978_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1960_l1978_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c1960_l1978_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1960_l1978_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c1960_l1978_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1979 fn c1961_l1979_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1961_l1979_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1961_l1979_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1961_l1979_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1961_l1979_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1980 fn c1962_l1980_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1962_l1980_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1962_l1980_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1962_l1980_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1962_l1980_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1981 fn c1963_l1981_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1963_l1981_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1963_l1981_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1963_l1981_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1963_l1981_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1982 fn c1964_l1982_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1964_l1982_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1964_l1982_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1964_l1982_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1964_l1982_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1983 fn c1965_l1983_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1965_l1983_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1965_l1983_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1965_l1983_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1965_l1983_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1984 fn c1966_l1984_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1966_l1984_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c1966_l1984_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1966_l1984_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1966_l1984_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1985 fn c1967_l1985_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1967_l1985_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1967_l1985_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1967_l1985_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1967_l1985_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1986 fn c1968_l1986_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1968_l1986_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c1968_l1986_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1968_l1986_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c1968_l1986_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1987 fn c1969_l1987_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1969_l1987_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1969_l1987_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1969_l1987_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1969_l1987_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1988 fn c1970_l1988_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1970_l1988_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1970_l1988_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1970_l1988_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1970_l1988_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1989 fn c1971_l1989_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1971_l1989_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1971_l1989_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1971_l1989_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1971_l1989_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1990 fn c1972_l1990_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1972_l1990_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1972_l1990_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1972_l1990_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1972_l1990_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1991 fn c1973_l1991_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1973_l1991_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1973_l1991_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1973_l1991_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1973_l1991_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1992 fn c1974_l1992_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1974_l1992_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1974_l1992_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1974_l1992_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1974_l1992_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1993 fn c1975_l1993_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1975_l1993_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1975_l1993_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1975_l1993_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1975_l1993_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1994 fn c1976_l1994_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1976_l1994_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c1976_l1994_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1976_l1994_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c1976_l1994_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1995 fn c1977_l1995_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1977_l1995_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1977_l1995_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1977_l1995_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1977_l1995_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1996 fn c1978_l1996_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1978_l1996_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1978_l1996_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1978_l1996_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1978_l1996_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1997 fn c1979_l1997_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1979_l1997_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1979_l1997_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1979_l1997_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1979_l1997_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1998 fn c1980_l1998_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1980_l1998_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1980_l1998_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1980_l1998_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1980_l1998_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1999 fn c1981_l1999_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1981_l1999_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1981_l1999_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1981_l1999_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1981_l1999_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2000 fn c1982_l2000_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1982_l2000_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c1982_l2000_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1982_l2000_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1982_l2000_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2001 fn c1983_l2001_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1983_l2001_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1983_l2001_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1983_l2001_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1983_l2001_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2002 fn c1984_l2002_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1984_l2002_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c1984_l2002_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1984_l2002_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1984_l2002_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2003 fn c1985_l2003_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1985_l2003_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1985_l2003_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1985_l2003_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1985_l2003_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2004 fn c1986_l2004_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1986_l2004_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1986_l2004_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1986_l2004_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1986_l2004_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2005 fn c1987_l2005_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1987_l2005_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1987_l2005_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1987_l2005_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1987_l2005_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2006 fn c1988_l2006_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1988_l2006_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1988_l2006_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1988_l2006_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1988_l2006_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2007 fn c1989_l2007_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1989_l2007_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1989_l2007_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1989_l2007_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1989_l2007_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2008 fn c1990_l2008_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1990_l2008_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1990_l2008_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1990_l2008_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1990_l2008_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2009 fn c1991_l2009_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1991_l2009_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1991_l2009_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1991_l2009_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1991_l2009_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2010 fn c1992_l2010_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1992_l2010_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1992_l2010_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1992_l2010_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1992_l2010_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2011 fn c1993_l2011_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1993_l2011_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1993_l2011_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1993_l2011_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1993_l2011_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2012 fn c1994_l2012_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1994_l2012_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c1994_l2012_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1994_l2012_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c1994_l2012_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2013 fn c1995_l2013_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1995_l2013_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1995_l2013_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1995_l2013_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1995_l2013_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2014 fn c1996_l2014_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1996_l2014_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c1996_l2014_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1996_l2014_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c1996_l2014_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2015 fn c1997_l2015_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1997_l2015_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1997_l2015_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1997_l2015_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1997_l2015_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2016 fn c1998_l2016_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1998_l2016_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c1998_l2016_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1998_l2016_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c1998_l2016_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2017 fn c1999_l2017_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1999_l2017_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c1999_l2017_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1999_l2017_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c1999_l2017_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2018 fn c2000_l2018_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2000_l2018_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2000_l2018_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2000_l2018_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2000_l2018_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -18339,7 +33598,13 @@ fn c2004_l2022_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2023 fn c2005_l2023_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2005_l2023_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -18347,15 +33612,32 @@ fn c2005_l2023_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2024 fn c2006_l2024_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2006_l2024_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2025 fn c2007_l2025_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2007_l2025_action_invoke"); - let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "max", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -18363,15 +33645,32 @@ fn c2007_l2025_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2026 fn c2008_l2026_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2008_l2026_action_invoke"); - let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2027 fn c2009_l2027_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2009_l2027_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -18379,15 +33678,32 @@ fn c2009_l2027_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2028 fn c2010_l2028_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2010_l2028_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2029 fn c2011_l2029_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2011_l2029_action_invoke"); - let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "max", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -18395,8 +33711,19 @@ fn c2011_l2029_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2030 fn c2012_l2030_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2012_l2030_action_invoke"); - let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } @@ -18499,7 +33826,13 @@ fn c2024_l2042_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2043 fn c2025_l2043_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2025_l2043_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -18507,15 +33840,32 @@ fn c2025_l2043_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2044 fn c2026_l2044_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2026_l2044_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2045 fn c2027_l2045_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2027_l2045_action_invoke"); - let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -18523,15 +33873,29 @@ fn c2027_l2045_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2046 fn c2028_l2046_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2028_l2046_action_invoke"); - let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2047 fn c2029_l2047_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2029_l2047_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -18547,7 +33911,10 @@ fn c2030_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2049 fn c2031_l2049_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2031_l2049_action_invoke"); - let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -18562,96 +33929,186 @@ fn c2032_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2051 fn c2033_l2051_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2033_l2051_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2033_l2051_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2033_l2051_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2033_l2051_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2052 fn c2034_l2052_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2034_l2052_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2034_l2052_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2034_l2052_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2034_l2052_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2053 fn c2035_l2053_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2035_l2053_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2035_l2053_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2035_l2053_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2035_l2053_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2054 fn c2036_l2054_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2036_l2054_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2036_l2054_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2036_l2054_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2036_l2054_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2055 fn c2037_l2055_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2037_l2055_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2037_l2055_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2037_l2055_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c2037_l2055_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2056 fn c2038_l2056_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2038_l2056_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2038_l2056_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2038_l2056_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c2038_l2056_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2057 fn c2039_l2057_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2039_l2057_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2039_l2057_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2039_l2057_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c2039_l2057_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2058 fn c2040_l2058_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2040_l2058_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2040_l2058_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2040_l2058_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c2040_l2058_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2059 fn c2041_l2059_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2041_l2059_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -18659,7 +34116,13 @@ fn c2041_l2059_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2060 fn c2042_l2060_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2042_l2060_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -18667,95 +34130,222 @@ fn c2042_l2060_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2061 fn c2043_l2061_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2043_l2061_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2062 fn c2044_l2062_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2044_l2062_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2063 fn c2045_l2063_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2045_l2063_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2064 fn c2046_l2064_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2046_l2064_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2065 fn c2047_l2065_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2047_l2065_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2066 fn c2048_l2066_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2048_l2066_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2067 fn c2049_l2067_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2049_l2067_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2068 fn c2050_l2068_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2050_l2068_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2069 fn c2051_l2069_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2051_l2069_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2070 fn c2052_l2070_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2052_l2070_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2071 fn c2053_l2071_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2053_l2071_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2072 fn c2054_l2072_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2054_l2072_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -18763,15 +34353,32 @@ fn c2054_l2072_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2073 fn c2055_l2073_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2055_l2073_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2074 fn c2056_l2074_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2056_l2074_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -18779,15 +34386,32 @@ fn c2056_l2074_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2075 fn c2057_l2075_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2057_l2075_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2076 fn c2058_l2076_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2058_l2076_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -18795,15 +34419,32 @@ fn c2058_l2076_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2077 fn c2059_l2077_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2059_l2077_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2078 fn c2060_l2078_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2060_l2078_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -18811,15 +34452,32 @@ fn c2060_l2078_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2079 fn c2061_l2079_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2061_l2079_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2080 fn c2062_l2080_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2062_l2080_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -18827,15 +34485,32 @@ fn c2062_l2080_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2081 fn c2063_l2081_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2063_l2081_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2082 fn c2064_l2082_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2064_l2082_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -18843,47 +34518,108 @@ fn c2064_l2082_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2083 fn c2065_l2083_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2065_l2083_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2084 fn c2066_l2084_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2066_l2084_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2085 fn c2067_l2085_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2067_l2085_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2086 fn c2068_l2086_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2068_l2086_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2087 fn c2069_l2087_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2069_l2087_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2088 fn c2070_l2088_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2070_l2088_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -18891,111 +34627,230 @@ fn c2070_l2088_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2089 fn c2071_l2089_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2071_l2089_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2090 fn c2072_l2090_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2072_l2090_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 2091 fn c2073_l2091_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2073_l2091_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2073_l2091_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2073_l2091_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2073_l2091_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2092 fn c2074_l2092_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2074_l2092_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2074_l2092_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2074_l2092_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2074_l2092_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2093 fn c2075_l2093_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2075_l2093_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2075_l2093_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2075_l2093_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2075_l2093_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2094 fn c2076_l2094_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2076_l2094_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2076_l2094_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2076_l2094_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2076_l2094_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2095 fn c2077_l2095_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2077_l2095_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2077_l2095_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2077_l2095_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2077_l2095_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2096 fn c2078_l2096_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2078_l2096_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2078_l2096_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2078_l2096_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2078_l2096_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2097 fn c2079_l2097_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2079_l2097_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2079_l2097_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2079_l2097_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2079_l2097_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2098 fn c2080_l2098_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2080_l2098_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2080_l2098_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2080_l2098_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2080_l2098_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2099 fn c2081_l2099_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2081_l2099_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -19003,7 +34858,13 @@ fn c2081_l2099_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2100 fn c2082_l2100_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2082_l2100_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -19011,95 +34872,222 @@ fn c2082_l2100_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2101 fn c2083_l2101_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2083_l2101_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2102 fn c2084_l2102_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2084_l2102_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2103 fn c2085_l2103_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2085_l2103_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2104 fn c2086_l2104_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2086_l2104_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2105 fn c2087_l2105_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2087_l2105_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2106 fn c2088_l2106_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2088_l2106_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2107 fn c2089_l2107_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2089_l2107_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2108 fn c2090_l2108_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2090_l2108_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2109 fn c2091_l2109_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2091_l2109_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2110 fn c2092_l2110_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2092_l2110_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2111 fn c2093_l2111_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2093_l2111_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2112 fn c2094_l2112_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2094_l2112_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -19107,15 +35095,32 @@ fn c2094_l2112_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2113 fn c2095_l2113_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2095_l2113_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2114 fn c2096_l2114_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2096_l2114_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -19123,15 +35128,32 @@ fn c2096_l2114_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2115 fn c2097_l2115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2097_l2115_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2116 fn c2098_l2116_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2098_l2116_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -19139,15 +35161,32 @@ fn c2098_l2116_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2117 fn c2099_l2117_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2099_l2117_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2118 fn c2100_l2118_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2100_l2118_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -19155,15 +35194,32 @@ fn c2100_l2118_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2119 fn c2101_l2119_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2101_l2119_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2120 fn c2102_l2120_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2102_l2120_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -19171,15 +35227,32 @@ fn c2102_l2120_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2121 fn c2103_l2121_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2103_l2121_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2122 fn c2104_l2122_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2104_l2122_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -19187,47 +35260,108 @@ fn c2104_l2122_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2123 fn c2105_l2123_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2105_l2123_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2124 fn c2106_l2124_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2106_l2124_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2125 fn c2107_l2125_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2107_l2125_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2126 fn c2108_l2126_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2108_l2126_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2127 fn c2109_l2127_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2109_l2127_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2128 fn c2110_l2128_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2110_l2128_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -19235,104 +35369,217 @@ fn c2110_l2128_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2129 fn c2111_l2129_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2111_l2129_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2130 fn c2112_l2130_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2112_l2130_action_invoke"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 2131 fn c2113_l2131_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2113_l2131_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2113_l2131_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2113_l2131_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2113_l2131_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2132 fn c2114_l2132_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2114_l2132_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2114_l2132_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2114_l2132_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2114_l2132_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2133 fn c2115_l2133_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2115_l2133_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2115_l2133_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2115_l2133_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2115_l2133_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2134 fn c2116_l2134_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2116_l2134_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2116_l2134_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2116_l2134_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2116_l2134_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2135 fn c2117_l2135_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2117_l2135_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2117_l2135_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2117_l2135_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2117_l2135_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2136 fn c2118_l2136_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2118_l2136_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2118_l2136_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2118_l2136_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2118_l2136_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2137 fn c2119_l2137_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2119_l2137_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2119_l2137_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2119_l2137_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2119_l2137_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2138 fn c2120_l2138_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2120_l2138_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2120_l2138_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2120_l2138_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2120_l2138_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -19371,23 +35618,51 @@ fn c2124_l2142_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2143 fn c2125_l2143_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2125_l2143_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2144 fn c2126_l2144_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2126_l2144_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2145 fn c2127_l2145_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2127_l2145_action_invoke"); - let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "max", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -19395,7 +35670,13 @@ fn c2127_l2145_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2146 fn c2128_l2146_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2128_l2146_action_invoke"); - let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "max", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -19403,23 +35684,51 @@ fn c2128_l2146_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2147 fn c2129_l2147_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2129_l2147_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2148 fn c2130_l2148_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2130_l2148_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2149 fn c2131_l2149_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2131_l2149_action_invoke"); - let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "max", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -19427,7 +35736,13 @@ fn c2131_l2149_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2150 fn c2132_l2150_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2132_l2150_action_invoke"); - let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "max", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -19531,7 +35846,13 @@ fn c2144_l2162_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2163 fn c2145_l2163_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2145_l2163_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -19539,15 +35860,32 @@ fn c2145_l2163_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2164 fn c2146_l2164_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2146_l2164_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2165 fn c2147_l2165_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2147_l2165_action_invoke"); - let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -19555,15 +35893,29 @@ fn c2147_l2165_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2166 fn c2148_l2166_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2148_l2166_action_invoke"); - let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2167 fn c2149_l2167_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2149_l2167_action_invoke"); - let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -19579,7 +35931,10 @@ fn c2150_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2169 fn c2151_l2169_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2151_l2169_action_invoke"); - let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -19594,89 +35949,173 @@ fn c2152_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2171 fn c2153_l2171_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2153_l2171_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2153_l2171_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2153_l2171_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2153_l2171_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2172 fn c2154_l2172_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2154_l2172_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2154_l2172_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2154_l2172_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2154_l2172_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2173 fn c2155_l2173_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2155_l2173_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2155_l2173_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2155_l2173_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2155_l2173_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2174 fn c2156_l2174_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2156_l2174_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2156_l2174_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2156_l2174_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2156_l2174_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2175 fn c2157_l2175_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2157_l2175_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2157_l2175_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2157_l2175_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c2157_l2175_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2176 fn c2158_l2176_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2158_l2176_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2158_l2176_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2158_l2176_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c2158_l2176_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2177 fn c2159_l2177_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2159_l2177_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2159_l2177_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2159_l2177_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c2159_l2177_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2178 fn c2160_l2178_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2160_l2178_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2160_l2178_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2160_l2178_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c2160_l2178_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -19715,23 +36154,51 @@ fn c2164_l2182_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2183 fn c2165_l2183_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2165_l2183_action_invoke"); - let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2184 fn c2166_l2184_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2166_l2184_action_invoke"); - let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2185 fn c2167_l2185_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2167_l2185_action_invoke"); - let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "max", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -19739,7 +36206,13 @@ fn c2167_l2185_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2186 fn c2168_l2186_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2168_l2186_action_invoke"); - let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "max", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -19747,23 +36220,51 @@ fn c2168_l2186_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2187 fn c2169_l2187_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2169_l2187_action_invoke"); - let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2188 fn c2170_l2188_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2170_l2188_action_invoke"); - let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2189 fn c2171_l2189_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2171_l2189_action_invoke"); - let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "max", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -19771,7 +36272,13 @@ fn c2171_l2189_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2190 fn c2172_l2190_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2172_l2190_action_invoke"); - let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "max", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -19875,7 +36382,13 @@ fn c2184_l2202_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2203 fn c2185_l2203_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2185_l2203_action_invoke"); - let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -19883,15 +36396,32 @@ fn c2185_l2203_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2204 fn c2186_l2204_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2186_l2204_action_invoke"); - let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2205 fn c2187_l2205_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2187_l2205_action_invoke"); - let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -19899,15 +36429,29 @@ fn c2187_l2205_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2206 fn c2188_l2206_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2188_l2206_action_invoke"); - let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2207 fn c2189_l2207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2189_l2207_action_invoke"); - let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -19923,7 +36467,10 @@ fn c2190_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2209 fn c2191_l2209_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2191_l2209_action_invoke"); - let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -19938,89 +36485,173 @@ fn c2192_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2211 fn c2193_l2211_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2193_l2211_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2193_l2211_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2193_l2211_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2193_l2211_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2212 fn c2194_l2212_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2194_l2212_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2194_l2212_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2194_l2212_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2194_l2212_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2213 fn c2195_l2213_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2195_l2213_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2195_l2213_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2195_l2213_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2195_l2213_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2214 fn c2196_l2214_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2196_l2214_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2196_l2214_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2196_l2214_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2196_l2214_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2215 fn c2197_l2215_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2197_l2215_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2197_l2215_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2197_l2215_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))], + ) + .unwrap() + .expect("Missing result in c2197_l2215_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2216 fn c2198_l2216_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2198_l2216_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2198_l2216_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2198_l2216_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))], + ) + .unwrap() + .expect("Missing result in c2198_l2216_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2217 fn c2199_l2217_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2199_l2217_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2199_l2217_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2199_l2217_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c2199_l2217_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2218 fn c2200_l2218_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2200_l2218_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2200_l2218_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2200_l2218_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c2200_l2218_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -20059,23 +36690,51 @@ fn c2204_l2222_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2223 fn c2205_l2223_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2205_l2223_action_invoke"); - let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2224 fn c2206_l2224_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2206_l2224_action_invoke"); - let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2225 fn c2207_l2225_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2207_l2225_action_invoke"); - let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "max", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -20083,7 +36742,13 @@ fn c2207_l2225_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2226 fn c2208_l2226_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2208_l2226_action_invoke"); - let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "max", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -20091,23 +36756,51 @@ fn c2208_l2226_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2227 fn c2209_l2227_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2209_l2227_action_invoke"); - let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2228 fn c2210_l2228_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2210_l2228_action_invoke"); - let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2229 fn c2211_l2229_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2211_l2229_action_invoke"); - let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "max", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -20115,7 +36808,13 @@ fn c2211_l2229_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2230 fn c2212_l2230_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2212_l2230_action_invoke"); - let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "max", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -20187,7 +36886,10 @@ fn c2220_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2239 fn c2221_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2221_l2239_action_invoke"); - let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "max", + &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -20195,7 +36897,10 @@ fn c2221_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2240 fn c2222_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2222_l2240_action_invoke"); - let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "max", + &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -20203,7 +36908,10 @@ fn c2222_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2241 fn c2223_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2223_l2241_action_invoke"); - let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "max", + &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -20211,7 +36919,10 @@ fn c2223_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2242 fn c2224_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2224_l2242_action_invoke"); - let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "max", + &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -20219,7 +36930,13 @@ fn c2224_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2243 fn c2225_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2225_l2243_action_invoke"); - let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -20227,15 +36944,32 @@ fn c2225_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2244 fn c2226_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2226_l2244_action_invoke"); - let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2245 fn c2227_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2227_l2245_action_invoke"); - let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -20243,15 +36977,29 @@ fn c2227_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2246 fn c2228_l2246_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2228_l2246_action_invoke"); - let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2247 fn c2229_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2229_l2247_action_invoke"); - let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -20259,7 +37007,10 @@ fn c2229_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2248 fn c2230_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2230_l2248_action_invoke"); - let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "max", + &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -20267,7 +37018,10 @@ fn c2230_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2249 fn c2231_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2231_l2249_action_invoke"); - let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -20275,103 +37029,208 @@ fn c2231_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2250 fn c2232_l2250_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2232_l2250_action_invoke"); - let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "max", + &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 2251 fn c2233_l2251_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2233_l2251_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2233_l2251_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2233_l2251_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2233_l2251_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2252 fn c2234_l2252_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2234_l2252_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2234_l2252_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2234_l2252_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2234_l2252_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2253 fn c2235_l2253_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2235_l2253_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2235_l2253_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2235_l2253_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2235_l2253_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2254 fn c2236_l2254_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2236_l2254_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2236_l2254_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2236_l2254_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2236_l2254_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2255 fn c2237_l2255_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2237_l2255_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2237_l2255_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2237_l2255_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2237_l2255_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2256 fn c2238_l2256_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2238_l2256_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2238_l2256_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2238_l2256_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2238_l2256_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2257 fn c2239_l2257_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2239_l2257_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2239_l2257_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2239_l2257_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2239_l2257_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2258 fn c2240_l2258_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2240_l2258_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2240_l2258_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2240_l2258_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2240_l2258_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2259 fn c2241_l2259_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2241_l2259_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -20379,7 +37238,13 @@ fn c2241_l2259_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2260 fn c2242_l2260_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2242_l2260_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -20387,87 +37252,203 @@ fn c2242_l2260_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2261 fn c2243_l2261_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2243_l2261_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2262 fn c2244_l2262_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2244_l2262_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2263 fn c2245_l2263_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2245_l2263_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2264 fn c2246_l2264_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2246_l2264_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2265 fn c2247_l2265_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2247_l2265_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2266 fn c2248_l2266_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2248_l2266_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2267 fn c2249_l2267_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2249_l2267_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2268 fn c2250_l2268_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2250_l2268_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2269 fn c2251_l2269_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2251_l2269_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2270 fn c2252_l2270_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2252_l2270_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2271 fn c2253_l2271_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2253_l2271_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -20475,7 +37456,13 @@ fn c2253_l2271_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2272 fn c2254_l2272_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2254_l2272_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -20483,23 +37470,51 @@ fn c2254_l2272_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2273 fn c2255_l2273_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2255_l2273_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2274 fn c2256_l2274_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2256_l2274_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2275 fn c2257_l2275_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2257_l2275_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -20507,7 +37522,13 @@ fn c2257_l2275_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2276 fn c2258_l2276_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2258_l2276_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -20515,23 +37536,51 @@ fn c2258_l2276_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2277 fn c2259_l2277_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2259_l2277_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2278 fn c2260_l2278_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2260_l2278_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2279 fn c2261_l2279_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2261_l2279_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -20539,7 +37588,13 @@ fn c2261_l2279_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2280 fn c2262_l2280_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2262_l2280_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -20547,63 +37602,146 @@ fn c2262_l2280_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2281 fn c2263_l2281_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2263_l2281_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2282 fn c2264_l2282_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2264_l2282_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2283 fn c2265_l2283_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2265_l2283_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2284 fn c2266_l2284_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2266_l2284_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2285 fn c2267_l2285_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2267_l2285_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2286 fn c2268_l2286_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2268_l2286_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2287 fn c2269_l2287_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2269_l2287_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2288 fn c2270_l2288_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2270_l2288_action_invoke"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -20611,111 +37749,227 @@ fn c2270_l2288_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2289 fn c2271_l2289_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2271_l2289_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2290 fn c2272_l2290_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2272_l2290_action_invoke"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 2291 fn c2273_l2291_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2273_l2291_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2273_l2291_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2273_l2291_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2273_l2291_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2292 fn c2274_l2292_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2274_l2292_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2274_l2292_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2274_l2292_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2274_l2292_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2293 fn c2275_l2293_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2275_l2293_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2275_l2293_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2275_l2293_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2275_l2293_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2294 fn c2276_l2294_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2276_l2294_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2276_l2294_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2276_l2294_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2276_l2294_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2295 fn c2277_l2295_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2277_l2295_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2277_l2295_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2277_l2295_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2277_l2295_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2296 fn c2278_l2296_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2278_l2296_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2278_l2296_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2278_l2296_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2278_l2296_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2297 fn c2279_l2297_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2279_l2297_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2279_l2297_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2279_l2297_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2279_l2297_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2298 fn c2280_l2298_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2280_l2298_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2280_l2298_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2280_l2298_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2280_l2298_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2299 fn c2281_l2299_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2281_l2299_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]); + let result = instance.call( + "max", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -20723,7 +37977,10 @@ fn c2281_l2299_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2300 fn c2282_l2300_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2282_l2300_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))]); + let result = instance.call( + "max", + &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -20747,23 +38004,51 @@ fn c2284_l2302_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2303 fn c2285_l2303_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2285_l2303_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2304 fn c2286_l2304_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2286_l2304_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "max", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 2305 fn c2287_l2305_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2287_l2305_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "max", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -20771,7 +38056,13 @@ fn c2287_l2305_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2306 fn c2288_l2306_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2288_l2306_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "max", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -20779,23 +38070,51 @@ fn c2288_l2306_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2307 fn c2289_l2307_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2289_l2307_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2308 fn c2290_l2308_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2290_l2308_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "max", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 2309 fn c2291_l2309_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2291_l2309_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "max", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -20803,7 +38122,13 @@ fn c2291_l2309_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2310 fn c2292_l2310_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2292_l2310_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "max", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -20811,7 +38136,10 @@ fn c2292_l2310_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2311 fn c2293_l2311_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2293_l2311_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]); + let result = instance.call( + "max", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -20819,7 +38147,10 @@ fn c2293_l2311_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2312 fn c2294_l2312_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2294_l2312_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))]); + let result = instance.call( + "max", + &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -20843,7 +38174,10 @@ fn c2296_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2315 fn c2297_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2297_l2315_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]); + let result = instance.call( + "max", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -20851,7 +38185,10 @@ fn c2297_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2316 fn c2298_l2316_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2298_l2316_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))]); + let result = instance.call( + "max", + &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -20875,7 +38212,10 @@ fn c2300_l2318_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2319 fn c2301_l2319_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2301_l2319_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "max", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -20883,7 +38223,10 @@ fn c2301_l2319_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2320 fn c2302_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2302_l2320_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "max", + &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -20891,7 +38234,10 @@ fn c2302_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2321 fn c2303_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2303_l2321_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "max", + &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -20899,7 +38245,10 @@ fn c2303_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2322 fn c2304_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2304_l2322_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "max", + &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -20907,23 +38256,51 @@ fn c2304_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2323 fn c2305_l2323_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2305_l2323_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2324 fn c2306_l2324_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2306_l2324_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "max", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2325 fn c2307_l2325_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2307_l2325_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32(f32::INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -20931,7 +38308,13 @@ fn c2307_l2325_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2326 fn c2308_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2308_l2326_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "max", + &[ + Value::F32(f32::INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -20939,7 +38322,10 @@ fn c2308_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2327 fn c2309_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2309_l2327_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -20947,7 +38333,10 @@ fn c2309_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2328 fn c2310_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2310_l2328_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "max", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -20955,7 +38344,10 @@ fn c2310_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2329 fn c2311_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2311_l2329_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -20963,976 +38355,1999 @@ fn c2311_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2330 fn c2312_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2312_l2330_action_invoke"); - let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "max", + &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } // Line 2331 fn c2313_l2331_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2313_l2331_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2313_l2331_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2313_l2331_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2313_l2331_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2332 fn c2314_l2332_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2314_l2332_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2314_l2332_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2314_l2332_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2314_l2332_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2333 fn c2315_l2333_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2315_l2333_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2315_l2333_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2315_l2333_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2315_l2333_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2334 fn c2316_l2334_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2316_l2334_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2316_l2334_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2316_l2334_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2316_l2334_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2335 fn c2317_l2335_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2317_l2335_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2317_l2335_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2317_l2335_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2317_l2335_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2336 fn c2318_l2336_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2318_l2336_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2318_l2336_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2318_l2336_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2318_l2336_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2337 fn c2319_l2337_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2319_l2337_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2319_l2337_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2319_l2337_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2319_l2337_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2338 fn c2320_l2338_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2320_l2338_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2320_l2338_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2320_l2338_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2320_l2338_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2339 fn c2321_l2339_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2321_l2339_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c2321_l2339_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2321_l2339_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2321_l2339_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2340 fn c2322_l2340_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2322_l2340_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c2322_l2340_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2322_l2340_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2322_l2340_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2341 fn c2323_l2341_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2323_l2341_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c2323_l2341_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2323_l2341_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c2323_l2341_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2342 fn c2324_l2342_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2324_l2342_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c2324_l2342_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2324_l2342_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c2324_l2342_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2343 fn c2325_l2343_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2325_l2343_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c2325_l2343_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2325_l2343_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2325_l2343_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2344 fn c2326_l2344_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2326_l2344_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]).unwrap().expect("Missing result in c2326_l2344_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2326_l2344_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2326_l2344_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2345 fn c2327_l2345_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2327_l2345_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c2327_l2345_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2327_l2345_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c2327_l2345_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2346 fn c2328_l2346_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2328_l2346_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]).unwrap().expect("Missing result in c2328_l2346_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2328_l2346_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))], + ) + .unwrap() + .expect("Missing result in c2328_l2346_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2347 fn c2329_l2347_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2329_l2347_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2329_l2347_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2329_l2347_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c2329_l2347_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2348 fn c2330_l2348_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2330_l2348_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2330_l2348_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2330_l2348_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c2330_l2348_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2349 fn c2331_l2349_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2331_l2349_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2331_l2349_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2331_l2349_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c2331_l2349_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2350 fn c2332_l2350_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2332_l2350_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2332_l2350_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2332_l2350_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c2332_l2350_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2351 fn c2333_l2351_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2333_l2351_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2333_l2351_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2333_l2351_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c2333_l2351_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2352 fn c2334_l2352_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2334_l2352_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2334_l2352_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2334_l2352_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c2334_l2352_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2353 fn c2335_l2353_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2335_l2353_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2335_l2353_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2335_l2353_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c2335_l2353_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2354 fn c2336_l2354_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2336_l2354_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2336_l2354_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2336_l2354_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ) + .unwrap() + .expect("Missing result in c2336_l2354_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2355 fn c2337_l2355_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2337_l2355_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2337_l2355_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2337_l2355_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c2337_l2355_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2356 fn c2338_l2356_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2338_l2356_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2338_l2356_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2338_l2356_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c2338_l2356_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2357 fn c2339_l2357_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2339_l2357_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2339_l2357_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2339_l2357_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c2339_l2357_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2358 fn c2340_l2358_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2340_l2358_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2340_l2358_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2340_l2358_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c2340_l2358_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2359 fn c2341_l2359_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2341_l2359_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2341_l2359_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2341_l2359_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c2341_l2359_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2360 fn c2342_l2360_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2342_l2360_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2342_l2360_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2342_l2360_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c2342_l2360_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2361 fn c2343_l2361_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2343_l2361_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2343_l2361_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2343_l2361_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c2343_l2361_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2362 fn c2344_l2362_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2344_l2362_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2344_l2362_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2344_l2362_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ) + .unwrap() + .expect("Missing result in c2344_l2362_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2363 fn c2345_l2363_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2345_l2363_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c2345_l2363_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2345_l2363_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c2345_l2363_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2364 fn c2346_l2364_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2346_l2364_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c2346_l2364_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2346_l2364_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c2346_l2364_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2365 fn c2347_l2365_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2347_l2365_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c2347_l2365_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2347_l2365_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c2347_l2365_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2366 fn c2348_l2366_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2348_l2366_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c2348_l2366_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2348_l2366_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c2348_l2366_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2367 fn c2349_l2367_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2349_l2367_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c2349_l2367_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2349_l2367_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c2349_l2367_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2368 fn c2350_l2368_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2350_l2368_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]).unwrap().expect("Missing result in c2350_l2368_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2350_l2368_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.5f32)), + ], + ) + .unwrap() + .expect("Missing result in c2350_l2368_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2369 fn c2351_l2369_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2351_l2369_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c2351_l2369_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2351_l2369_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c2351_l2369_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2370 fn c2352_l2370_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2352_l2370_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]).unwrap().expect("Missing result in c2352_l2370_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2352_l2370_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))], + ) + .unwrap() + .expect("Missing result in c2352_l2370_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2371 fn c2353_l2371_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2353_l2371_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c2353_l2371_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2353_l2371_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2353_l2371_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2372 fn c2354_l2372_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2354_l2372_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c2354_l2372_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2354_l2372_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2354_l2372_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2373 fn c2355_l2373_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2355_l2373_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c2355_l2373_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2355_l2373_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c2355_l2373_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2374 fn c2356_l2374_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2356_l2374_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c2356_l2374_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2356_l2374_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c2356_l2374_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2375 fn c2357_l2375_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2357_l2375_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c2357_l2375_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2357_l2375_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2357_l2375_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2376 fn c2358_l2376_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2358_l2376_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]).unwrap().expect("Missing result in c2358_l2376_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2358_l2376_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-1.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2358_l2376_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2377 fn c2359_l2377_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2359_l2377_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c2359_l2377_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2359_l2377_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c2359_l2377_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2378 fn c2360_l2378_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2360_l2378_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]).unwrap().expect("Missing result in c2360_l2378_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2360_l2378_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))], + ) + .unwrap() + .expect("Missing result in c2360_l2378_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2379 fn c2361_l2379_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2361_l2379_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c2361_l2379_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2361_l2379_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c2361_l2379_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2380 fn c2362_l2380_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2362_l2380_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c2362_l2380_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2362_l2380_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c2362_l2380_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2381 fn c2363_l2381_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2363_l2381_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c2363_l2381_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2363_l2381_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c2363_l2381_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2382 fn c2364_l2382_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2364_l2382_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c2364_l2382_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2364_l2382_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c2364_l2382_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2383 fn c2365_l2383_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2365_l2383_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c2365_l2383_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2365_l2383_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c2365_l2383_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2384 fn c2366_l2384_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2366_l2384_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c2366_l2384_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2366_l2384_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c2366_l2384_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2385 fn c2367_l2385_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2367_l2385_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c2367_l2385_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2367_l2385_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c2367_l2385_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2386 fn c2368_l2386_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2368_l2386_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]).unwrap().expect("Missing result in c2368_l2386_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2368_l2386_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((6.2831855f32)), + ], + ) + .unwrap() + .expect("Missing result in c2368_l2386_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2387 fn c2369_l2387_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2369_l2387_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2369_l2387_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2369_l2387_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2369_l2387_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2388 fn c2370_l2388_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2370_l2388_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2370_l2388_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2370_l2388_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2370_l2388_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2389 fn c2371_l2389_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2371_l2389_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2371_l2389_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2371_l2389_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2371_l2389_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2390 fn c2372_l2390_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2372_l2390_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2372_l2390_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2372_l2390_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2372_l2390_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2391 fn c2373_l2391_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2373_l2391_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2373_l2391_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2373_l2391_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2373_l2391_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2392 fn c2374_l2392_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2374_l2392_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2374_l2392_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2374_l2392_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2374_l2392_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2393 fn c2375_l2393_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2375_l2393_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2375_l2393_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2375_l2393_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2375_l2393_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2394 fn c2376_l2394_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2376_l2394_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2376_l2394_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2376_l2394_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ) + .unwrap() + .expect("Missing result in c2376_l2394_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2395 fn c2377_l2395_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2377_l2395_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c2377_l2395_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2377_l2395_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2377_l2395_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2396 fn c2378_l2396_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2378_l2396_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c2378_l2396_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2378_l2396_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2378_l2396_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2397 fn c2379_l2397_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2379_l2397_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c2379_l2397_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2379_l2397_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2379_l2397_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2398 fn c2380_l2398_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2380_l2398_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c2380_l2398_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2380_l2398_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2380_l2398_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2399 fn c2381_l2399_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2381_l2399_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c2381_l2399_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2381_l2399_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2381_l2399_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2400 fn c2382_l2400_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2382_l2400_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c2382_l2400_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2382_l2400_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2382_l2400_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2401 fn c2383_l2401_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2383_l2401_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c2383_l2401_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2383_l2401_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2383_l2401_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2402 fn c2384_l2402_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2384_l2402_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c2384_l2402_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2384_l2402_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2384_l2402_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2403 fn c2385_l2403_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2385_l2403_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2385_l2403_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2385_l2403_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2385_l2403_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2404 fn c2386_l2404_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2386_l2404_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2386_l2404_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2386_l2404_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2386_l2404_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2405 fn c2387_l2405_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2387_l2405_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2387_l2405_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2387_l2405_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2387_l2405_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2406 fn c2388_l2406_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2388_l2406_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2388_l2406_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2388_l2406_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2388_l2406_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2407 fn c2389_l2407_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2389_l2407_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2389_l2407_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2389_l2407_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2389_l2407_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2408 fn c2390_l2408_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2390_l2408_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2390_l2408_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2390_l2408_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2390_l2408_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2409 fn c2391_l2409_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2391_l2409_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2391_l2409_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2391_l2409_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2391_l2409_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2410 fn c2392_l2410_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2392_l2410_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2392_l2410_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2392_l2410_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2392_l2410_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2411 fn c2393_l2411_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2393_l2411_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2393_l2411_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2393_l2411_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2393_l2411_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2412 fn c2394_l2412_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2394_l2412_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2394_l2412_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2394_l2412_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4290772992)), + ], + ) + .unwrap() + .expect("Missing result in c2394_l2412_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2413 fn c2395_l2413_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2395_l2413_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2395_l2413_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2395_l2413_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2395_l2413_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2414 fn c2396_l2414_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2396_l2414_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2396_l2414_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2396_l2414_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4288675840)), + ], + ) + .unwrap() + .expect("Missing result in c2396_l2414_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2415 fn c2397_l2415_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2397_l2415_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2397_l2415_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2397_l2415_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2397_l2415_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2416 fn c2398_l2416_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2398_l2416_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2398_l2416_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2398_l2416_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2143289344)), + ], + ) + .unwrap() + .expect("Missing result in c2398_l2416_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2417 fn c2399_l2417_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2399_l2417_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2399_l2417_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2399_l2417_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2399_l2417_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2418 fn c2400_l2418_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2400_l2418_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2400_l2418_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2400_l2418_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2141192192)), + ], + ) + .unwrap() + .expect("Missing result in c2400_l2418_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -21954,50 +40369,94 @@ fn c2402_l2420_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2421 fn c2403_l2421_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2403_l2421_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]).unwrap().expect("Missing result in c2403_l2421_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2403_l2421_assert_return_canonical_nan" + ); + let result = instance + .call( + "sqrt", + &[Value::F32( + (-0.000000000000000000000000000000000000000000001f32), + )], + ) + .unwrap() + .expect("Missing result in c2403_l2421_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2422 fn c2404_l2422_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2404_l2422_action_invoke"); - let result = instance.call("sqrt", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000003743392f32))))); + let result = instance.call( + "sqrt", + &[Value::F32( + (0.000000000000000000000000000000000000000000001f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.00000000000000000000003743392f32)))) + ); result.map(|_| ()) } // Line 2423 fn c2405_l2423_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2405_l2423_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]).unwrap().expect("Missing result in c2405_l2423_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2405_l2423_assert_return_canonical_nan" + ); + let result = instance + .call( + "sqrt", + &[Value::F32( + (-0.000000000000000000000000000000000000011754944f32), + )], + ) + .unwrap() + .expect("Missing result in c2405_l2423_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2424 fn c2406_l2424_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2406_l2424_action_invoke"); - let result = instance.call("sqrt", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000010842022f32))))); + let result = instance.call( + "sqrt", + &[Value::F32( + (0.000000000000000000000000000000000000011754944f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.00000000000000000010842022f32)))) + ); result.map(|_| ()) } // Line 2425 fn c2407_l2425_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2407_l2425_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F32((-0.5f32))]).unwrap().expect("Missing result in c2407_l2425_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2407_l2425_assert_return_canonical_nan" + ); + let result = instance + .call("sqrt", &[Value::F32((-0.5f32))]) + .unwrap() + .expect("Missing result in c2407_l2425_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22011,12 +40470,18 @@ fn c2408_l2426_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2427 fn c2409_l2427_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2409_l2427_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F32((-1.0f32))]).unwrap().expect("Missing result in c2409_l2427_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2409_l2427_assert_return_canonical_nan" + ); + let result = instance + .call("sqrt", &[Value::F32((-1.0f32))]) + .unwrap() + .expect("Missing result in c2409_l2427_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22030,12 +40495,18 @@ fn c2410_l2428_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2429 fn c2411_l2429_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2411_l2429_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F32((-6.2831855f32))]).unwrap().expect("Missing result in c2411_l2429_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2411_l2429_assert_return_canonical_nan" + ); + let result = instance + .call("sqrt", &[Value::F32((-6.2831855f32))]) + .unwrap() + .expect("Missing result in c2411_l2429_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22049,31 +40520,49 @@ fn c2412_l2430_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2431 fn c2413_l2431_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2413_l2431_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F32((-340282350000000000000000000000000000000.0f32))]).unwrap().expect("Missing result in c2413_l2431_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2413_l2431_assert_return_canonical_nan" + ); + let result = instance + .call( + "sqrt", + &[Value::F32((-340282350000000000000000000000000000000.0f32))], + ) + .unwrap() + .expect("Missing result in c2413_l2431_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2432 fn c2414_l2432_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2414_l2432_action_invoke"); - let result = instance.call("sqrt", &[Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "sqrt", + &[Value::F32((340282350000000000000000000000000000000.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((18446743000000000000.0f32))))); result.map(|_| ()) } // Line 2433 fn c2415_l2433_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2415_l2433_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c2415_l2433_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2415_l2433_assert_return_canonical_nan" + ); + let result = instance + .call("sqrt", &[Value::F32(f32::NEG_INFINITY)]) + .unwrap() + .expect("Missing result in c2415_l2433_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22087,45 +40576,69 @@ fn c2416_l2434_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2435 fn c2417_l2435_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2417_l2435_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2417_l2435_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2417_l2435_assert_return_canonical_nan" + ); + let result = instance + .call("sqrt", &[Value::F32(f32::from_bits(4290772992))]) + .unwrap() + .expect("Missing result in c2417_l2435_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2436 fn c2418_l2436_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2418_l2436_assert_return_arithmetic_nan"); - let result = instance.call("sqrt", &[Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2418_l2436_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2418_l2436_assert_return_arithmetic_nan" + ); + let result = instance + .call("sqrt", &[Value::F32(f32::from_bits(4288675840))]) + .unwrap() + .expect("Missing result in c2418_l2436_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2437 fn c2419_l2437_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2419_l2437_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2419_l2437_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2419_l2437_assert_return_canonical_nan" + ); + let result = instance + .call("sqrt", &[Value::F32(f32::from_bits(2143289344))]) + .unwrap() + .expect("Missing result in c2419_l2437_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2438 fn c2420_l2438_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2420_l2438_assert_return_arithmetic_nan"); - let result = instance.call("sqrt", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2420_l2438_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2420_l2438_assert_return_arithmetic_nan" + ); + let result = instance + .call("sqrt", &[Value::F32(f32::from_bits(2141192192))]) + .unwrap() + .expect("Missing result in c2420_l2438_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22148,7 +40661,12 @@ fn c2422_l2440_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2441 fn c2423_l2441_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2423_l2441_action_invoke"); - let result = instance.call("floor", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "floor", + &[Value::F32( + (-0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -22156,7 +40674,12 @@ fn c2423_l2441_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2442 fn c2424_l2442_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2424_l2442_action_invoke"); - let result = instance.call("floor", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "floor", + &[Value::F32( + (0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -22164,7 +40687,12 @@ fn c2424_l2442_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2443 fn c2425_l2443_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2425_l2443_action_invoke"); - let result = instance.call("floor", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "floor", + &[Value::F32( + (-0.000000000000000000000000000000000000011754944f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -22172,7 +40700,12 @@ fn c2425_l2443_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2444 fn c2426_l2444_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2426_l2444_action_invoke"); - let result = instance.call("floor", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "floor", + &[Value::F32( + (0.000000000000000000000000000000000000011754944f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -22228,16 +40761,32 @@ fn c2432_l2450_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2451 fn c2433_l2451_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2433_l2451_action_invoke"); - let result = instance.call("floor", &[Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "floor", + &[Value::F32((-340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2452 fn c2434_l2452_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2434_l2452_action_invoke"); - let result = instance.call("floor", &[Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "floor", + &[Value::F32((340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -22259,45 +40808,69 @@ fn c2436_l2454_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2455 fn c2437_l2455_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2437_l2455_assert_return_canonical_nan"); - let result = instance.call("floor", &[Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2437_l2455_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2437_l2455_assert_return_canonical_nan" + ); + let result = instance + .call("floor", &[Value::F32(f32::from_bits(4290772992))]) + .unwrap() + .expect("Missing result in c2437_l2455_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2456 fn c2438_l2456_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2438_l2456_assert_return_arithmetic_nan"); - let result = instance.call("floor", &[Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2438_l2456_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2438_l2456_assert_return_arithmetic_nan" + ); + let result = instance + .call("floor", &[Value::F32(f32::from_bits(4288675840))]) + .unwrap() + .expect("Missing result in c2438_l2456_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2457 fn c2439_l2457_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2439_l2457_assert_return_canonical_nan"); - let result = instance.call("floor", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2439_l2457_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2439_l2457_assert_return_canonical_nan" + ); + let result = instance + .call("floor", &[Value::F32(f32::from_bits(2143289344))]) + .unwrap() + .expect("Missing result in c2439_l2457_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2458 fn c2440_l2458_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2440_l2458_assert_return_arithmetic_nan"); - let result = instance.call("floor", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2440_l2458_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2440_l2458_assert_return_arithmetic_nan" + ); + let result = instance + .call("floor", &[Value::F32(f32::from_bits(2141192192))]) + .unwrap() + .expect("Missing result in c2440_l2458_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22320,7 +40893,12 @@ fn c2442_l2460_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2461 fn c2443_l2461_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2443_l2461_action_invoke"); - let result = instance.call("ceil", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ceil", + &[Value::F32( + (-0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -22328,7 +40906,12 @@ fn c2443_l2461_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2462 fn c2444_l2462_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2444_l2462_action_invoke"); - let result = instance.call("ceil", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ceil", + &[Value::F32( + (0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -22336,7 +40919,12 @@ fn c2444_l2462_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2463 fn c2445_l2463_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2445_l2463_action_invoke"); - let result = instance.call("ceil", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ceil", + &[Value::F32( + (-0.000000000000000000000000000000000000011754944f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -22344,7 +40932,12 @@ fn c2445_l2463_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2464 fn c2446_l2464_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2446_l2464_action_invoke"); - let result = instance.call("ceil", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ceil", + &[Value::F32( + (0.000000000000000000000000000000000000011754944f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -22400,16 +40993,32 @@ fn c2452_l2470_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2471 fn c2453_l2471_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2453_l2471_action_invoke"); - let result = instance.call("ceil", &[Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "ceil", + &[Value::F32((-340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2472 fn c2454_l2472_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2454_l2472_action_invoke"); - let result = instance.call("ceil", &[Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "ceil", + &[Value::F32((340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -22431,45 +41040,69 @@ fn c2456_l2474_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2475 fn c2457_l2475_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2457_l2475_assert_return_canonical_nan"); - let result = instance.call("ceil", &[Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2457_l2475_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2457_l2475_assert_return_canonical_nan" + ); + let result = instance + .call("ceil", &[Value::F32(f32::from_bits(4290772992))]) + .unwrap() + .expect("Missing result in c2457_l2475_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2476 fn c2458_l2476_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2458_l2476_assert_return_arithmetic_nan"); - let result = instance.call("ceil", &[Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2458_l2476_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2458_l2476_assert_return_arithmetic_nan" + ); + let result = instance + .call("ceil", &[Value::F32(f32::from_bits(4288675840))]) + .unwrap() + .expect("Missing result in c2458_l2476_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2477 fn c2459_l2477_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2459_l2477_assert_return_canonical_nan"); - let result = instance.call("ceil", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2459_l2477_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2459_l2477_assert_return_canonical_nan" + ); + let result = instance + .call("ceil", &[Value::F32(f32::from_bits(2143289344))]) + .unwrap() + .expect("Missing result in c2459_l2477_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2478 fn c2460_l2478_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2460_l2478_assert_return_arithmetic_nan"); - let result = instance.call("ceil", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2460_l2478_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2460_l2478_assert_return_arithmetic_nan" + ); + let result = instance + .call("ceil", &[Value::F32(f32::from_bits(2141192192))]) + .unwrap() + .expect("Missing result in c2460_l2478_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22492,7 +41125,12 @@ fn c2462_l2480_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2481 fn c2463_l2481_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2463_l2481_action_invoke"); - let result = instance.call("trunc", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "trunc", + &[Value::F32( + (-0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -22500,7 +41138,12 @@ fn c2463_l2481_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2482 fn c2464_l2482_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2464_l2482_action_invoke"); - let result = instance.call("trunc", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "trunc", + &[Value::F32( + (0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -22508,7 +41151,12 @@ fn c2464_l2482_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2483 fn c2465_l2483_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2465_l2483_action_invoke"); - let result = instance.call("trunc", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "trunc", + &[Value::F32( + (-0.000000000000000000000000000000000000011754944f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -22516,7 +41164,12 @@ fn c2465_l2483_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2484 fn c2466_l2484_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2466_l2484_action_invoke"); - let result = instance.call("trunc", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "trunc", + &[Value::F32( + (0.000000000000000000000000000000000000011754944f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -22572,16 +41225,32 @@ fn c2472_l2490_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2491 fn c2473_l2491_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2473_l2491_action_invoke"); - let result = instance.call("trunc", &[Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "trunc", + &[Value::F32((-340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2492 fn c2474_l2492_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2474_l2492_action_invoke"); - let result = instance.call("trunc", &[Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "trunc", + &[Value::F32((340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -22603,45 +41272,69 @@ fn c2476_l2494_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2495 fn c2477_l2495_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2477_l2495_assert_return_canonical_nan"); - let result = instance.call("trunc", &[Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2477_l2495_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2477_l2495_assert_return_canonical_nan" + ); + let result = instance + .call("trunc", &[Value::F32(f32::from_bits(4290772992))]) + .unwrap() + .expect("Missing result in c2477_l2495_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2496 fn c2478_l2496_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2478_l2496_assert_return_arithmetic_nan"); - let result = instance.call("trunc", &[Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2478_l2496_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2478_l2496_assert_return_arithmetic_nan" + ); + let result = instance + .call("trunc", &[Value::F32(f32::from_bits(4288675840))]) + .unwrap() + .expect("Missing result in c2478_l2496_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2497 fn c2479_l2497_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2479_l2497_assert_return_canonical_nan"); - let result = instance.call("trunc", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2479_l2497_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2479_l2497_assert_return_canonical_nan" + ); + let result = instance + .call("trunc", &[Value::F32(f32::from_bits(2143289344))]) + .unwrap() + .expect("Missing result in c2479_l2497_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2498 fn c2480_l2498_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2480_l2498_assert_return_arithmetic_nan"); - let result = instance.call("trunc", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2480_l2498_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2480_l2498_assert_return_arithmetic_nan" + ); + let result = instance + .call("trunc", &[Value::F32(f32::from_bits(2141192192))]) + .unwrap() + .expect("Missing result in c2480_l2498_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22664,7 +41357,12 @@ fn c2482_l2500_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2501 fn c2483_l2501_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2483_l2501_action_invoke"); - let result = instance.call("nearest", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "nearest", + &[Value::F32( + (-0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -22672,7 +41370,12 @@ fn c2483_l2501_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2502 fn c2484_l2502_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2484_l2502_action_invoke"); - let result = instance.call("nearest", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "nearest", + &[Value::F32( + (0.000000000000000000000000000000000000000000001f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -22680,7 +41383,12 @@ fn c2484_l2502_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2503 fn c2485_l2503_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2485_l2503_action_invoke"); - let result = instance.call("nearest", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "nearest", + &[Value::F32( + (-0.000000000000000000000000000000000000011754944f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -22688,7 +41396,12 @@ fn c2485_l2503_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2504 fn c2486_l2504_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2486_l2504_action_invoke"); - let result = instance.call("nearest", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "nearest", + &[Value::F32( + (0.000000000000000000000000000000000000011754944f32), + )], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -22744,16 +41457,32 @@ fn c2492_l2510_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2511 fn c2493_l2511_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2493_l2511_action_invoke"); - let result = instance.call("nearest", &[Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "nearest", + &[Value::F32((-340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 2512 fn c2494_l2512_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2494_l2512_action_invoke"); - let result = instance.call("nearest", &[Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "nearest", + &[Value::F32((340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -22775,45 +41504,69 @@ fn c2496_l2514_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2515 fn c2497_l2515_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2497_l2515_assert_return_canonical_nan"); - let result = instance.call("nearest", &[Value::F32(f32::from_bits(4290772992))]).unwrap().expect("Missing result in c2497_l2515_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2497_l2515_assert_return_canonical_nan" + ); + let result = instance + .call("nearest", &[Value::F32(f32::from_bits(4290772992))]) + .unwrap() + .expect("Missing result in c2497_l2515_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2516 fn c2498_l2516_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2498_l2516_assert_return_arithmetic_nan"); - let result = instance.call("nearest", &[Value::F32(f32::from_bits(4288675840))]).unwrap().expect("Missing result in c2498_l2516_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2498_l2516_assert_return_arithmetic_nan" + ); + let result = instance + .call("nearest", &[Value::F32(f32::from_bits(4288675840))]) + .unwrap() + .expect("Missing result in c2498_l2516_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2517 fn c2499_l2517_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2499_l2517_assert_return_canonical_nan"); - let result = instance.call("nearest", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c2499_l2517_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2499_l2517_assert_return_canonical_nan" + ); + let result = instance + .call("nearest", &[Value::F32(f32::from_bits(2143289344))]) + .unwrap() + .expect("Missing result in c2499_l2517_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2518 fn c2500_l2518_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2500_l2518_assert_return_arithmetic_nan"); - let result = instance.call("nearest", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c2500_l2518_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2500_l2518_assert_return_arithmetic_nan" + ); + let result = instance + .call("nearest", &[Value::F32(f32::from_bits(2141192192))]) + .unwrap() + .expect("Missing result in c2500_l2518_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } diff --git a/lib/runtime/tests/spectests/f32_bitwise.rs b/lib/runtime/tests/spectests/f32_bitwise.rs index 7cdfae540..7fd73878b 100644 --- a/lib/runtime/tests/spectests/f32_bitwise.rs +++ b/lib/runtime/tests/spectests/f32_bitwise.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 4 fn create_module_1() -> Box { @@ -38,8 +34,11 @@ fn create_module_1() -> Box { (export \"copysign\" (func 2))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -82,7 +81,13 @@ fn c4_l13_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 14 fn c5_l14_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c5_l14_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -90,7 +95,13 @@ fn c5_l14_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 15 fn c6_l15_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c6_l15_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -98,7 +109,13 @@ fn c6_l15_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 16 fn c7_l16_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c7_l16_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -106,7 +123,13 @@ fn c7_l16_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 17 fn c8_l17_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c8_l17_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -114,7 +137,13 @@ fn c8_l17_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 18 fn c9_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c9_l18_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -122,7 +151,13 @@ fn c9_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 19 fn c10_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c10_l19_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -130,7 +165,13 @@ fn c10_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 20 fn c11_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c11_l20_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -138,7 +179,13 @@ fn c11_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 21 fn c12_l21_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c12_l21_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -210,7 +257,10 @@ fn c20_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 30 fn c21_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c21_l30_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((-0.0f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -218,7 +268,10 @@ fn c21_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 31 fn c22_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c22_l31_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((-0.0f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -226,7 +279,10 @@ fn c22_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 32 fn c23_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c23_l32_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((0.0f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -234,7 +290,10 @@ fn c23_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 33 fn c24_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c24_l33_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((0.0f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -242,7 +301,13 @@ fn c24_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 34 fn c25_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c25_l34_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -250,7 +315,13 @@ fn c25_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 35 fn c26_l35_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c26_l35_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -258,7 +329,13 @@ fn c26_l35_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 36 fn c27_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c27_l36_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -266,7 +343,13 @@ fn c27_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 37 fn c28_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c28_l37_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -274,7 +357,10 @@ fn c28_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 38 fn c29_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c29_l38_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -282,7 +368,10 @@ fn c29_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 39 fn c30_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c30_l39_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((-0.0f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -290,7 +379,10 @@ fn c30_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 40 fn c31_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c31_l40_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -298,7 +390,10 @@ fn c31_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 41 fn c32_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c32_l41_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((0.0f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -306,7 +401,13 @@ fn c32_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 42 fn c33_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c33_l42_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -314,7 +415,13 @@ fn c33_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 43 fn c34_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c34_l43_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -322,7 +429,10 @@ fn c34_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 44 fn c35_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c35_l44_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "copysign", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -330,7 +440,10 @@ fn c35_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 45 fn c36_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c36_l45_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "copysign", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -338,576 +451,1368 @@ fn c36_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 46 fn c37_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c37_l46_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 47 fn c38_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c38_l47_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 48 fn c39_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c39_l48_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 49 fn c40_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c40_l49_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 50 fn c41_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c41_l50_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 51 fn c42_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c42_l51_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 52 fn c43_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c43_l52_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 53 fn c44_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c44_l53_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 54 fn c45_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c45_l54_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 55 fn c46_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c46_l55_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 56 fn c47_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c47_l56_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 57 fn c48_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c48_l57_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 58 fn c49_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c49_l58_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 59 fn c50_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c50_l59_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 60 fn c51_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c51_l60_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 61 fn c52_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c52_l61_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 62 fn c53_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c53_l62_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 63 fn c54_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c54_l63_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 64 fn c55_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c55_l64_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 65 fn c56_l65_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c56_l65_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 66 fn c57_l66_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c57_l66_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 67 fn c58_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c58_l67_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 68 fn c59_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c59_l68_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 69 fn c60_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c60_l69_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 70 fn c61_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c61_l70_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 71 fn c62_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c62_l71_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 72 fn c63_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c63_l72_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 73 fn c64_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c64_l73_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 74 fn c65_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c65_l74_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 75 fn c66_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c66_l75_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 76 fn c67_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c67_l76_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 77 fn c68_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c68_l77_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 78 fn c69_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c69_l78_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 79 fn c70_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c70_l79_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 80 fn c71_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c71_l80_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 81 fn c72_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c72_l81_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 82 fn c73_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c73_l82_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 83 fn c74_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c74_l83_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 84 fn c75_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c75_l84_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 85 fn c76_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c76_l85_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 86 fn c77_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c77_l86_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 87 fn c78_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c78_l87_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 88 fn c79_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c79_l88_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 89 fn c80_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c80_l89_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 90 fn c81_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c81_l90_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 91 fn c82_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c82_l91_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 92 fn c83_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c83_l92_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 93 fn c84_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c84_l93_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 94 fn c85_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c85_l94_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 95 fn c86_l95_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c86_l95_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 96 fn c87_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c87_l96_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 97 fn c88_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c88_l97_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 98 fn c89_l98_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c89_l98_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 99 fn c90_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c90_l99_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 100 fn c91_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c91_l100_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 101 fn c92_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c92_l101_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 102 fn c93_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c93_l102_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 103 fn c94_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c94_l103_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 104 fn c95_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c95_l104_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 105 fn c96_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c96_l105_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 106 fn c97_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c97_l106_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 107 fn c98_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c98_l107_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 108 fn c99_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c99_l108_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 109 fn c100_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c100_l109_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 110 fn c101_l110_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c101_l110_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 111 fn c102_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c102_l111_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 112 fn c103_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c103_l112_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 113 fn c104_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c104_l113_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 114 fn c105_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c105_l114_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 115 fn c106_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c106_l115_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 116 fn c107_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c107_l116_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 117 fn c108_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c108_l117_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } @@ -946,7 +1851,13 @@ fn c112_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 122 fn c113_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c113_l122_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -954,7 +1865,13 @@ fn c113_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 123 fn c114_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c114_l123_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -962,7 +1879,13 @@ fn c114_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 124 fn c115_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c115_l124_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -970,7 +1893,13 @@ fn c115_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 125 fn c116_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c116_l125_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -978,7 +1907,13 @@ fn c116_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 126 fn c117_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c117_l126_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -986,7 +1921,13 @@ fn c117_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 127 fn c118_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c118_l127_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -994,7 +1935,13 @@ fn c118_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 128 fn c119_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c119_l128_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -1002,7 +1949,13 @@ fn c119_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 129 fn c120_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c120_l129_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -1074,7 +2027,10 @@ fn c128_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 138 fn c129_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c129_l138_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((-0.5f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -1082,7 +2038,10 @@ fn c129_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 139 fn c130_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c130_l139_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((-0.5f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -1090,7 +2049,10 @@ fn c130_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 140 fn c131_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c131_l140_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((0.5f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -1098,7 +2060,10 @@ fn c131_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 141 fn c132_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c132_l141_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((0.5f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -1106,7 +2071,13 @@ fn c132_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 142 fn c133_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c133_l142_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -1114,7 +2085,13 @@ fn c133_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 143 fn c134_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c134_l143_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -1122,7 +2099,13 @@ fn c134_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 144 fn c135_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c135_l144_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -1130,7 +2113,13 @@ fn c135_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 145 fn c136_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c136_l145_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -1138,7 +2127,10 @@ fn c136_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 146 fn c137_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c137_l146_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -1146,7 +2138,10 @@ fn c137_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 147 fn c138_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c138_l147_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((-0.5f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -1154,7 +2149,10 @@ fn c138_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 148 fn c139_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c139_l148_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -1162,7 +2160,10 @@ fn c139_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 149 fn c140_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c140_l149_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((0.5f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -1170,7 +2171,13 @@ fn c140_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 150 fn c141_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c141_l150_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -1178,7 +2185,13 @@ fn c141_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 151 fn c142_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c142_l151_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -1186,7 +2199,10 @@ fn c142_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 152 fn c143_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c143_l152_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "copysign", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.5f32))))); result.map(|_| ()) } @@ -1194,7 +2210,10 @@ fn c143_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 153 fn c144_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c144_l153_action_invoke"); - let result = instance.call("copysign", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "copysign", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::F32((0.5f32))))); result.map(|_| ()) } @@ -1234,7 +2253,13 @@ fn c148_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 158 fn c149_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c149_l158_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1242,7 +2267,13 @@ fn c149_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 159 fn c150_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c150_l159_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1250,7 +2281,13 @@ fn c150_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 160 fn c151_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c151_l160_action_invoke"); - let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1258,7 +2295,13 @@ fn c151_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 161 fn c152_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c152_l161_action_invoke"); - let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1266,7 +2309,13 @@ fn c152_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 162 fn c153_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c153_l162_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1274,7 +2323,13 @@ fn c153_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 163 fn c154_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c154_l163_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1282,7 +2337,13 @@ fn c154_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 164 fn c155_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c155_l164_action_invoke"); - let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1290,7 +2351,13 @@ fn c155_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 165 fn c156_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c156_l165_action_invoke"); - let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1362,7 +2429,10 @@ fn c164_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 174 fn c165_l174_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c165_l174_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((-1.0f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1370,7 +2440,10 @@ fn c165_l174_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 175 fn c166_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c166_l175_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((-1.0f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1378,7 +2451,10 @@ fn c166_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 176 fn c167_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c167_l176_action_invoke"); - let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((1.0f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1386,7 +2462,10 @@ fn c167_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 177 fn c168_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c168_l177_action_invoke"); - let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((1.0f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1394,7 +2473,13 @@ fn c168_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 178 fn c169_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c169_l178_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1402,7 +2487,13 @@ fn c169_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 179 fn c170_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c170_l179_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1410,7 +2501,13 @@ fn c170_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 180 fn c171_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c171_l180_action_invoke"); - let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1418,7 +2515,13 @@ fn c171_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 181 fn c172_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c172_l181_action_invoke"); - let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1426,7 +2529,10 @@ fn c172_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 182 fn c173_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c173_l182_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1434,7 +2540,10 @@ fn c173_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 183 fn c174_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c174_l183_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((-1.0f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1442,7 +2551,10 @@ fn c174_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 184 fn c175_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c175_l184_action_invoke"); - let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1450,7 +2562,10 @@ fn c175_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 185 fn c176_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c176_l185_action_invoke"); - let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((1.0f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1458,7 +2573,13 @@ fn c176_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 186 fn c177_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c177_l186_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1466,7 +2587,13 @@ fn c177_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 187 fn c178_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c178_l187_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1474,7 +2601,10 @@ fn c178_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 188 fn c179_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c179_l188_action_invoke"); - let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "copysign", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -1482,7 +2612,10 @@ fn c179_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 189 fn c180_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c180_l189_action_invoke"); - let result = instance.call("copysign", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "copysign", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1490,7 +2623,10 @@ fn c180_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 190 fn c181_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c181_l190_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32((-6.2831855f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1498,7 +2634,10 @@ fn c181_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 191 fn c182_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c182_l191_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((0.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32((-6.2831855f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1506,7 +2645,10 @@ fn c182_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 192 fn c183_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c183_l192_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32((6.2831855f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1514,7 +2656,10 @@ fn c183_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 193 fn c184_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c184_l193_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((0.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32((6.2831855f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1522,7 +2667,13 @@ fn c184_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 194 fn c185_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c185_l194_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1530,7 +2681,13 @@ fn c185_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 195 fn c186_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c186_l195_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1538,7 +2695,13 @@ fn c186_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 196 fn c187_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c187_l196_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1546,7 +2709,13 @@ fn c187_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 197 fn c188_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c188_l197_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1554,7 +2723,13 @@ fn c188_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 198 fn c189_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c189_l198_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1562,7 +2737,13 @@ fn c189_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 199 fn c190_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c190_l199_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1570,7 +2751,13 @@ fn c190_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 200 fn c191_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c191_l200_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1578,7 +2765,13 @@ fn c191_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 201 fn c192_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c192_l201_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1586,7 +2779,10 @@ fn c192_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 202 fn c193_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c193_l202_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "copysign", + &[Value::F32((-6.2831855f32)), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1594,7 +2790,10 @@ fn c193_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 203 fn c194_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c194_l203_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((0.5f32))]); + let result = instance.call( + "copysign", + &[Value::F32((-6.2831855f32)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1602,7 +2801,10 @@ fn c194_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 204 fn c195_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c195_l204_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "copysign", + &[Value::F32((6.2831855f32)), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1610,7 +2812,10 @@ fn c195_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 205 fn c196_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c196_l205_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((0.5f32))]); + let result = instance.call( + "copysign", + &[Value::F32((6.2831855f32)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1618,7 +2823,10 @@ fn c196_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 206 fn c197_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c197_l206_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32((-6.2831855f32)), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1626,7 +2834,10 @@ fn c197_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 207 fn c198_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c198_l207_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((1.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32((-6.2831855f32)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1634,7 +2845,10 @@ fn c198_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 208 fn c199_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c199_l208_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32((6.2831855f32)), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1642,7 +2856,10 @@ fn c199_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 209 fn c200_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c200_l209_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((1.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32((6.2831855f32)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1650,7 +2867,10 @@ fn c200_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 210 fn c201_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c201_l210_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1658,7 +2878,10 @@ fn c201_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 211 fn c202_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c202_l211_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1666,7 +2889,10 @@ fn c202_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 212 fn c203_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c203_l212_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1674,7 +2900,10 @@ fn c203_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 213 fn c204_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c204_l213_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1682,7 +2911,13 @@ fn c204_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 214 fn c205_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c205_l214_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1690,7 +2925,13 @@ fn c205_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 215 fn c206_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c206_l215_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1698,7 +2939,13 @@ fn c206_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 216 fn c207_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c207_l216_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1706,7 +2953,13 @@ fn c207_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 217 fn c208_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c208_l217_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32((6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1714,7 +2967,10 @@ fn c208_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 218 fn c209_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c209_l218_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1722,7 +2978,10 @@ fn c209_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 219 fn c210_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c210_l219_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1730,7 +2989,10 @@ fn c210_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 220 fn c211_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c211_l220_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1738,7 +3000,10 @@ fn c211_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 221 fn c212_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c212_l221_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1746,7 +3011,13 @@ fn c212_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 222 fn c213_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c213_l222_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1754,7 +3025,13 @@ fn c213_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 223 fn c214_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c214_l223_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "copysign", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1762,7 +3039,13 @@ fn c214_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 224 fn c215_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c215_l224_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "copysign", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32))))); result.map(|_| ()) } @@ -1770,7 +3053,13 @@ fn c215_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 225 fn c216_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c216_l225_action_invoke"); - let result = instance.call("copysign", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "copysign", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((6.2831855f32))))); result.map(|_| ()) } @@ -1778,295 +3067,694 @@ fn c216_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 226 fn c217_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c217_l226_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 227 fn c218_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c218_l227_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 228 fn c219_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c219_l228_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 229 fn c220_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c220_l229_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 230 fn c221_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c221_l230_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 231 fn c222_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c222_l231_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 232 fn c223_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c223_l232_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 233 fn c224_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c224_l233_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 234 fn c225_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c225_l234_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 235 fn c226_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c226_l235_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 236 fn c227_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c227_l236_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 237 fn c228_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c228_l237_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 238 fn c229_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c229_l238_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 239 fn c230_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c230_l239_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 240 fn c231_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c231_l240_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 241 fn c232_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c232_l241_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 242 fn c233_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c233_l242_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 243 fn c234_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c234_l243_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 244 fn c235_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c235_l244_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 245 fn c236_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c236_l245_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 246 fn c237_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c237_l246_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 247 fn c238_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c238_l247_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 248 fn c239_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c239_l248_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 249 fn c240_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c240_l249_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 250 fn c241_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c241_l250_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 251 fn c242_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c242_l251_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 252 fn c243_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c243_l252_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 253 fn c244_l253_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c244_l253_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 254 fn c245_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c245_l254_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 255 fn c246_l255_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c246_l255_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 256 fn c247_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c247_l256_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 257 fn c248_l257_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c248_l257_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 258 fn c249_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c249_l258_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 259 fn c250_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c250_l259_action_invoke"); - let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 260 fn c251_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c251_l260_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 261 fn c252_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c252_l261_action_invoke"); - let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "copysign", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 262 fn c253_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c253_l262_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2074,7 +3762,10 @@ fn c253_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 263 fn c254_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c254_l263_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::NEG_INFINITY), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2082,7 +3773,10 @@ fn c254_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 264 fn c255_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c255_l264_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((-0.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::INFINITY), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2090,7 +3784,10 @@ fn c255_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 265 fn c256_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c256_l265_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((0.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::INFINITY), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2098,7 +3795,13 @@ fn c256_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 266 fn c257_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c257_l266_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2106,7 +3809,13 @@ fn c257_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 267 fn c258_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c258_l267_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2114,7 +3823,13 @@ fn c258_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 268 fn c259_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c259_l268_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2122,7 +3837,13 @@ fn c259_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 269 fn c260_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c260_l269_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2130,7 +3851,13 @@ fn c260_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 270 fn c261_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c261_l270_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2138,7 +3865,13 @@ fn c261_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 271 fn c262_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c262_l271_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2146,7 +3879,13 @@ fn c262_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 272 fn c263_l272_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c263_l272_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2154,7 +3893,13 @@ fn c263_l272_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 273 fn c264_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c264_l273_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2162,7 +3907,10 @@ fn c264_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 274 fn c265_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c265_l274_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2170,7 +3918,10 @@ fn c265_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 275 fn c266_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c266_l275_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::NEG_INFINITY), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2178,7 +3929,10 @@ fn c266_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 276 fn c267_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c267_l276_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((-0.5f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::INFINITY), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2186,7 +3940,10 @@ fn c267_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 277 fn c268_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c268_l277_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((0.5f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::INFINITY), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2194,7 +3951,10 @@ fn c268_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 278 fn c269_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c269_l278_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2202,7 +3962,10 @@ fn c269_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 279 fn c270_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c270_l279_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::NEG_INFINITY), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2210,7 +3973,10 @@ fn c270_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 280 fn c271_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c271_l280_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((-1.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::INFINITY), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2218,7 +3984,10 @@ fn c271_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 281 fn c272_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c272_l281_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((1.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::INFINITY), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2226,7 +3995,10 @@ fn c272_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 282 fn c273_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c273_l282_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2234,7 +4006,10 @@ fn c273_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 283 fn c274_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c274_l283_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2242,7 +4017,10 @@ fn c274_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 284 fn c275_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c275_l284_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2250,7 +4028,10 @@ fn c275_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 285 fn c276_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c276_l285_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2258,7 +4039,13 @@ fn c276_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 286 fn c277_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c277_l286_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2266,7 +4053,13 @@ fn c277_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 287 fn c278_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c278_l287_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2274,7 +4067,13 @@ fn c278_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 288 fn c279_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c279_l288_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2282,7 +4081,13 @@ fn c279_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 289 fn c280_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c280_l289_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2290,7 +4095,10 @@ fn c280_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 290 fn c281_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c281_l290_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2298,7 +4106,10 @@ fn c281_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 291 fn c282_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c282_l291_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2306,7 +4117,10 @@ fn c282_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 292 fn c283_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c283_l292_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2314,7 +4128,10 @@ fn c283_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 293 fn c284_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c284_l293_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2322,7 +4139,13 @@ fn c284_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 294 fn c285_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c285_l294_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2330,7 +4153,13 @@ fn c285_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 295 fn c286_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c286_l295_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2338,7 +4167,13 @@ fn c286_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 296 fn c287_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c287_l296_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -2346,7 +4181,13 @@ fn c287_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 297 fn c288_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c288_l297_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2354,504 +4195,810 @@ fn c288_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 298 fn c289_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c289_l298_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.0f32)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 299 fn c290_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c290_l299_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 300 fn c291_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c291_l300_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.0f32)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 301 fn c292_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c292_l301_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 302 fn c293_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c293_l302_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 303 fn c294_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c294_l303_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 304 fn c295_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c295_l304_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 305 fn c296_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c296_l305_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 306 fn c297_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c297_l306_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 307 fn c298_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c298_l307_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 308 fn c299_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c299_l308_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 309 fn c300_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c300_l309_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 310 fn c301_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c301_l310_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.5f32)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 311 fn c302_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c302_l311_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 312 fn c303_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c303_l312_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.5f32)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 313 fn c304_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c304_l313_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 314 fn c305_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c305_l314_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-1.0f32)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 315 fn c306_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c306_l315_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 316 fn c307_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c307_l316_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-1.0f32)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 317 fn c308_l317_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c308_l317_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]); + let result = instance.call( + "copysign", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 318 fn c309_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c309_l318_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-6.2831855f32)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 319 fn c310_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c310_l319_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((6.2831855f32)), + ], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 320 fn c311_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c311_l320_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-6.2831855f32)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 321 fn c312_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c312_l321_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((6.2831855f32)), + ], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 322 fn c313_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c313_l322_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 323 fn c314_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c314_l323_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 324 fn c315_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c315_l324_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 325 fn c316_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c316_l325_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 326 fn c317_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c317_l326_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::NEG_INFINITY), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 327 fn c318_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c318_l327_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::INFINITY), + ], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 328 fn c319_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c319_l328_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::NEG_INFINITY), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 329 fn c320_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c320_l329_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::INFINITY), + ], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 330 fn c321_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c321_l330_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4290772992)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 331 fn c322_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c322_l331_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2143289344)), + ], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 332 fn c323_l332_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c323_l332_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4290772992)), + ], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 333 fn c324_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c324_l333_action_invoke"); - let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "copysign", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2143289344)), + ], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2874,32 +5021,72 @@ fn c326_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 336 fn c327_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c327_l336_action_invoke"); - let result = instance.call("abs", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "abs", + &[Value::F32( + (-0.000000000000000000000000000000000000000000001f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 337 fn c328_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c328_l337_action_invoke"); - let result = instance.call("abs", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "abs", + &[Value::F32( + (0.000000000000000000000000000000000000000000001f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 338 fn c329_l338_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c329_l338_action_invoke"); - let result = instance.call("abs", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "abs", + &[Value::F32( + (-0.000000000000000000000000000000000000011754944f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 339 fn c330_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c330_l339_action_invoke"); - let result = instance.call("abs", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "abs", + &[Value::F32( + (0.000000000000000000000000000000000000011754944f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } @@ -2954,16 +5141,32 @@ fn c336_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 346 fn c337_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c337_l346_action_invoke"); - let result = instance.call("abs", &[Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "abs", + &[Value::F32((-340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 347 fn c338_l347_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c338_l347_action_invoke"); - let result = instance.call("abs", &[Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "abs", + &[Value::F32((340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -2988,12 +5191,15 @@ fn c341_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c341_l350_action_invoke"); let result = instance.call("abs", &[Value::F32(f32::from_bits(4290772992))]); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3002,12 +5208,15 @@ fn c342_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c342_l351_action_invoke"); let result = instance.call("abs", &[Value::F32(f32::from_bits(2143289344))]); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3030,32 +5239,72 @@ fn c344_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 354 fn c345_l354_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c345_l354_action_invoke"); - let result = instance.call("neg", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "neg", + &[Value::F32( + (-0.000000000000000000000000000000000000000000001f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 355 fn c346_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c346_l355_action_invoke"); - let result = instance.call("neg", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "neg", + &[Value::F32( + (0.000000000000000000000000000000000000000000001f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 356 fn c347_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c347_l356_action_invoke"); - let result = instance.call("neg", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "neg", + &[Value::F32( + (-0.000000000000000000000000000000000000011754944f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 357 fn c348_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c348_l357_action_invoke"); - let result = instance.call("neg", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "neg", + &[Value::F32( + (0.000000000000000000000000000000000000011754944f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } @@ -3110,16 +5359,32 @@ fn c354_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 364 fn c355_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c355_l364_action_invoke"); - let result = instance.call("neg", &[Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "neg", + &[Value::F32((-340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 365 fn c356_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c356_l365_action_invoke"); - let result = instance.call("neg", &[Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "neg", + &[Value::F32((340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -3144,12 +5409,15 @@ fn c359_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c359_l368_action_invoke"); let result = instance.call("neg", &[Value::F32(f32::from_bits(4290772992))]); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3158,12 +5426,15 @@ fn c360_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c360_l369_action_invoke"); let result = instance.call("neg", &[Value::F32(f32::from_bits(2143289344))]); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } diff --git a/lib/runtime/tests/spectests/f32_cmp.rs b/lib/runtime/tests/spectests/f32_cmp.rs index 994375fcc..e08b699f4 100644 --- a/lib/runtime/tests/spectests/f32_cmp.rs +++ b/lib/runtime/tests/spectests/f32_cmp.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 4 fn create_module_1() -> Box { @@ -54,8 +50,11 @@ fn create_module_1() -> Box { (export \"ge\" (func 5))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -98,7 +97,13 @@ fn c4_l16_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 17 fn c5_l17_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c5_l17_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -106,7 +111,13 @@ fn c5_l17_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 18 fn c6_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c6_l18_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -114,7 +125,13 @@ fn c6_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 19 fn c7_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c7_l19_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -122,7 +139,13 @@ fn c7_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 20 fn c8_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c8_l20_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -130,7 +153,13 @@ fn c8_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 21 fn c9_l21_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c9_l21_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -138,7 +167,13 @@ fn c9_l21_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 22 fn c10_l22_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c10_l22_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -146,7 +181,13 @@ fn c10_l22_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 23 fn c11_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c11_l23_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -154,7 +195,13 @@ fn c11_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 24 fn c12_l24_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c12_l24_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -258,7 +305,13 @@ fn c24_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 37 fn c25_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c25_l37_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -266,7 +319,13 @@ fn c25_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 38 fn c26_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c26_l38_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -274,7 +333,13 @@ fn c26_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 39 fn c27_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c27_l39_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -282,7 +347,13 @@ fn c27_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 40 fn c28_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c28_l40_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -290,7 +361,10 @@ fn c28_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 41 fn c29_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c29_l41_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -322,7 +396,13 @@ fn c32_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 45 fn c33_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c33_l45_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -330,7 +410,13 @@ fn c33_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 46 fn c34_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c34_l46_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -338,7 +424,13 @@ fn c34_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 47 fn c35_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c35_l47_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -346,7 +438,13 @@ fn c35_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 48 fn c36_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c36_l48_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -354,7 +452,10 @@ fn c36_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 49 fn c37_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c37_l49_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -362,7 +463,10 @@ fn c37_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 50 fn c38_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c38_l50_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -370,7 +474,10 @@ fn c38_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 51 fn c39_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c39_l51_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -378,7 +485,10 @@ fn c39_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 52 fn c40_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c40_l52_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -386,7 +496,13 @@ fn c40_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 53 fn c41_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c41_l53_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -394,7 +510,13 @@ fn c41_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 54 fn c42_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c42_l54_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -402,7 +524,13 @@ fn c42_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 55 fn c43_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c43_l55_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -410,7 +538,13 @@ fn c43_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 56 fn c44_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c44_l56_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -418,7 +552,13 @@ fn c44_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 57 fn c45_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c45_l57_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -426,7 +566,13 @@ fn c45_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 58 fn c46_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c46_l58_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -434,7 +580,13 @@ fn c46_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 59 fn c47_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c47_l59_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -442,7 +594,13 @@ fn c47_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 60 fn c48_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c48_l60_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -450,7 +608,13 @@ fn c48_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 61 fn c49_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c49_l61_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -458,7 +622,13 @@ fn c49_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 62 fn c50_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c50_l62_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -466,7 +636,13 @@ fn c50_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 63 fn c51_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c51_l63_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -474,7 +650,13 @@ fn c51_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 64 fn c52_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c52_l64_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -482,7 +664,13 @@ fn c52_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 65 fn c53_l65_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c53_l65_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -490,7 +678,13 @@ fn c53_l65_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 66 fn c54_l66_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c54_l66_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -498,7 +692,13 @@ fn c54_l66_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 67 fn c55_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c55_l67_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -506,7 +706,13 @@ fn c55_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 68 fn c56_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c56_l68_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -514,7 +720,13 @@ fn c56_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 69 fn c57_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c57_l69_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -522,7 +734,13 @@ fn c57_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 70 fn c58_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c58_l70_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -530,7 +748,13 @@ fn c58_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 71 fn c59_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c59_l71_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -538,7 +762,13 @@ fn c59_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 72 fn c60_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c60_l72_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -546,7 +776,13 @@ fn c60_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 73 fn c61_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c61_l73_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -554,7 +790,13 @@ fn c61_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 74 fn c62_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c62_l74_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -562,7 +804,13 @@ fn c62_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 75 fn c63_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c63_l75_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -570,7 +818,13 @@ fn c63_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 76 fn c64_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c64_l76_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -578,7 +832,13 @@ fn c64_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 77 fn c65_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c65_l77_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -586,7 +846,13 @@ fn c65_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 78 fn c66_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c66_l78_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -594,7 +860,13 @@ fn c66_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 79 fn c67_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c67_l79_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -602,7 +874,13 @@ fn c67_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 80 fn c68_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c68_l80_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -610,7 +888,13 @@ fn c68_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 81 fn c69_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c69_l81_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -618,7 +902,13 @@ fn c69_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 82 fn c70_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c70_l82_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -626,7 +916,13 @@ fn c70_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 83 fn c71_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c71_l83_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -634,7 +930,13 @@ fn c71_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 84 fn c72_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c72_l84_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -642,7 +944,13 @@ fn c72_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 85 fn c73_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c73_l85_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -650,7 +958,13 @@ fn c73_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 86 fn c74_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c74_l86_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -658,7 +972,13 @@ fn c74_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 87 fn c75_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c75_l87_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -666,7 +986,13 @@ fn c75_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 88 fn c76_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c76_l88_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -674,7 +1000,13 @@ fn c76_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 89 fn c77_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c77_l89_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -682,7 +1014,13 @@ fn c77_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 90 fn c78_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c78_l90_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -690,7 +1028,13 @@ fn c78_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 91 fn c79_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c79_l91_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -698,7 +1042,13 @@ fn c79_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 92 fn c80_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c80_l92_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -706,7 +1056,13 @@ fn c80_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 93 fn c81_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c81_l93_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -714,7 +1070,13 @@ fn c81_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 94 fn c82_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c82_l94_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -722,7 +1084,13 @@ fn c82_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 95 fn c83_l95_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c83_l95_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -730,7 +1098,13 @@ fn c83_l95_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 96 fn c84_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c84_l96_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -738,7 +1112,13 @@ fn c84_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 97 fn c85_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c85_l97_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -746,7 +1126,13 @@ fn c85_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 98 fn c86_l98_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c86_l98_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -754,7 +1140,13 @@ fn c86_l98_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 99 fn c87_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c87_l99_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -762,7 +1154,13 @@ fn c87_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 100 fn c88_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c88_l100_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -770,7 +1168,13 @@ fn c88_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 101 fn c89_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c89_l101_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -778,7 +1182,13 @@ fn c89_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 102 fn c90_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c90_l102_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -786,7 +1196,13 @@ fn c90_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 103 fn c91_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c91_l103_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -794,7 +1210,13 @@ fn c91_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 104 fn c92_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c92_l104_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -802,7 +1224,13 @@ fn c92_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 105 fn c93_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c93_l105_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -810,7 +1238,13 @@ fn c93_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 106 fn c94_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c94_l106_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -818,7 +1252,13 @@ fn c94_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 107 fn c95_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c95_l107_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -826,7 +1266,13 @@ fn c95_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 108 fn c96_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c96_l108_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -834,7 +1280,13 @@ fn c96_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 109 fn c97_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c97_l109_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -842,7 +1294,13 @@ fn c97_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 110 fn c98_l110_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c98_l110_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -850,7 +1308,13 @@ fn c98_l110_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 111 fn c99_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c99_l111_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -858,7 +1322,13 @@ fn c99_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 112 fn c100_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c100_l112_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -866,7 +1336,13 @@ fn c100_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 113 fn c101_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c101_l113_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -874,7 +1350,13 @@ fn c101_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 114 fn c102_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c102_l114_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -882,7 +1364,13 @@ fn c102_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 115 fn c103_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c103_l115_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -890,7 +1378,13 @@ fn c103_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 116 fn c104_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c104_l116_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -898,7 +1392,13 @@ fn c104_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 117 fn c105_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c105_l117_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -906,7 +1406,13 @@ fn c105_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 118 fn c106_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c106_l118_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -914,7 +1420,13 @@ fn c106_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 119 fn c107_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c107_l119_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -922,7 +1434,13 @@ fn c107_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 120 fn c108_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c108_l120_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -930,7 +1448,13 @@ fn c108_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 121 fn c109_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c109_l121_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -938,7 +1462,13 @@ fn c109_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 122 fn c110_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c110_l122_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -946,7 +1476,13 @@ fn c110_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 123 fn c111_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c111_l123_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -954,7 +1490,13 @@ fn c111_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 124 fn c112_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c112_l124_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -962,7 +1504,13 @@ fn c112_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 125 fn c113_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c113_l125_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -970,7 +1518,13 @@ fn c113_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 126 fn c114_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c114_l126_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -978,7 +1532,13 @@ fn c114_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 127 fn c115_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c115_l127_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -986,7 +1546,13 @@ fn c115_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 128 fn c116_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c116_l128_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -994,7 +1560,13 @@ fn c116_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 129 fn c117_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c117_l129_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1002,7 +1574,13 @@ fn c117_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 130 fn c118_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c118_l130_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1010,7 +1588,13 @@ fn c118_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 131 fn c119_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c119_l131_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1018,7 +1602,13 @@ fn c119_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 132 fn c120_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c120_l132_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1058,7 +1648,13 @@ fn c124_l136_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 137 fn c125_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c125_l137_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1066,7 +1662,13 @@ fn c125_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 138 fn c126_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c126_l138_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1074,7 +1676,13 @@ fn c126_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 139 fn c127_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c127_l139_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1082,7 +1690,13 @@ fn c127_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 140 fn c128_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c128_l140_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1090,7 +1704,13 @@ fn c128_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 141 fn c129_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c129_l141_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1098,7 +1718,13 @@ fn c129_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 142 fn c130_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c130_l142_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1106,7 +1732,13 @@ fn c130_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 143 fn c131_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c131_l143_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1114,7 +1746,13 @@ fn c131_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 144 fn c132_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c132_l144_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1218,7 +1856,13 @@ fn c144_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 157 fn c145_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c145_l157_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1226,7 +1870,13 @@ fn c145_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 158 fn c146_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c146_l158_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1234,7 +1884,13 @@ fn c146_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 159 fn c147_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c147_l159_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1242,7 +1898,13 @@ fn c147_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 160 fn c148_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c148_l160_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1250,7 +1912,10 @@ fn c148_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 161 fn c149_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c149_l161_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1282,7 +1947,13 @@ fn c152_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 165 fn c153_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c153_l165_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1290,7 +1961,13 @@ fn c153_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 166 fn c154_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c154_l166_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1298,7 +1975,13 @@ fn c154_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 167 fn c155_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c155_l167_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1306,7 +1989,13 @@ fn c155_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 168 fn c156_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c156_l168_action_invoke"); - let result = instance.call("eq", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1314,7 +2003,10 @@ fn c156_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 169 fn c157_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c157_l169_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1322,7 +2014,10 @@ fn c157_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 170 fn c158_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c158_l170_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1330,7 +2025,10 @@ fn c158_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 171 fn c159_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c159_l171_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1338,7 +2036,10 @@ fn c159_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 172 fn c160_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c160_l172_action_invoke"); - let result = instance.call("eq", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1378,7 +2079,13 @@ fn c164_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 177 fn c165_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c165_l177_action_invoke"); - let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1386,7 +2093,13 @@ fn c165_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 178 fn c166_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c166_l178_action_invoke"); - let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1394,7 +2107,13 @@ fn c166_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 179 fn c167_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c167_l179_action_invoke"); - let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1402,7 +2121,13 @@ fn c167_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 180 fn c168_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c168_l180_action_invoke"); - let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1410,7 +2135,13 @@ fn c168_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 181 fn c169_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c169_l181_action_invoke"); - let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1418,7 +2149,13 @@ fn c169_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 182 fn c170_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c170_l182_action_invoke"); - let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1426,7 +2163,13 @@ fn c170_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 183 fn c171_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c171_l183_action_invoke"); - let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1434,7 +2177,13 @@ fn c171_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 184 fn c172_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c172_l184_action_invoke"); - let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1538,7 +2287,13 @@ fn c184_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 197 fn c185_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c185_l197_action_invoke"); - let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1546,7 +2301,13 @@ fn c185_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 198 fn c186_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c186_l198_action_invoke"); - let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1554,7 +2315,13 @@ fn c186_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 199 fn c187_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c187_l199_action_invoke"); - let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1562,7 +2329,13 @@ fn c187_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 200 fn c188_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c188_l200_action_invoke"); - let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1570,7 +2343,10 @@ fn c188_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 201 fn c189_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c189_l201_action_invoke"); - let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1602,7 +2378,13 @@ fn c192_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 205 fn c193_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c193_l205_action_invoke"); - let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1610,7 +2392,13 @@ fn c193_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 206 fn c194_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c194_l206_action_invoke"); - let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1618,7 +2406,13 @@ fn c194_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 207 fn c195_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c195_l207_action_invoke"); - let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1626,7 +2420,13 @@ fn c195_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 208 fn c196_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c196_l208_action_invoke"); - let result = instance.call("eq", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1634,7 +2434,10 @@ fn c196_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 209 fn c197_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c197_l209_action_invoke"); - let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1642,7 +2445,10 @@ fn c197_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 210 fn c198_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c198_l210_action_invoke"); - let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1650,7 +2456,10 @@ fn c198_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 211 fn c199_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c199_l211_action_invoke"); - let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1658,7 +2467,10 @@ fn c199_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 212 fn c200_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c200_l212_action_invoke"); - let result = instance.call("eq", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1698,7 +2510,13 @@ fn c204_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 217 fn c205_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c205_l217_action_invoke"); - let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1706,7 +2524,13 @@ fn c205_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 218 fn c206_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c206_l218_action_invoke"); - let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1714,7 +2538,13 @@ fn c206_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 219 fn c207_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c207_l219_action_invoke"); - let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1722,7 +2552,13 @@ fn c207_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 220 fn c208_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c208_l220_action_invoke"); - let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1730,7 +2566,13 @@ fn c208_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 221 fn c209_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c209_l221_action_invoke"); - let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1738,7 +2580,13 @@ fn c209_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 222 fn c210_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c210_l222_action_invoke"); - let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1746,7 +2594,13 @@ fn c210_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 223 fn c211_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c211_l223_action_invoke"); - let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1754,7 +2608,13 @@ fn c211_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 224 fn c212_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c212_l224_action_invoke"); - let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1826,7 +2686,10 @@ fn c220_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 233 fn c221_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c221_l233_action_invoke"); - let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "eq", + &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1834,7 +2697,10 @@ fn c221_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 234 fn c222_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c222_l234_action_invoke"); - let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "eq", + &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1842,7 +2708,10 @@ fn c222_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 235 fn c223_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c223_l235_action_invoke"); - let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "eq", + &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1850,7 +2719,10 @@ fn c223_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 236 fn c224_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c224_l236_action_invoke"); - let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "eq", + &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1858,7 +2730,13 @@ fn c224_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 237 fn c225_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c225_l237_action_invoke"); - let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1866,7 +2744,13 @@ fn c225_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 238 fn c226_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c226_l238_action_invoke"); - let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1874,7 +2758,13 @@ fn c226_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 239 fn c227_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c227_l239_action_invoke"); - let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1882,7 +2772,13 @@ fn c227_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 240 fn c228_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c228_l240_action_invoke"); - let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1890,7 +2786,10 @@ fn c228_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 241 fn c229_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c229_l241_action_invoke"); - let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1898,7 +2797,10 @@ fn c229_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 242 fn c230_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c230_l242_action_invoke"); - let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "eq", + &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1906,7 +2808,10 @@ fn c230_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 243 fn c231_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c231_l243_action_invoke"); - let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1914,7 +2819,10 @@ fn c231_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 244 fn c232_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c232_l244_action_invoke"); - let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "eq", + &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1922,7 +2830,13 @@ fn c232_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 245 fn c233_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c233_l245_action_invoke"); - let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1930,7 +2844,13 @@ fn c233_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 246 fn c234_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c234_l246_action_invoke"); - let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1938,7 +2858,13 @@ fn c234_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 247 fn c235_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c235_l247_action_invoke"); - let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1946,7 +2872,13 @@ fn c235_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 248 fn c236_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c236_l248_action_invoke"); - let result = instance.call("eq", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1954,7 +2886,13 @@ fn c236_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 249 fn c237_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c237_l249_action_invoke"); - let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1962,7 +2900,13 @@ fn c237_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 250 fn c238_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c238_l250_action_invoke"); - let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1970,7 +2914,13 @@ fn c238_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 251 fn c239_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c239_l251_action_invoke"); - let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1978,7 +2928,13 @@ fn c239_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 252 fn c240_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c240_l252_action_invoke"); - let result = instance.call("eq", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1986,7 +2942,13 @@ fn c240_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 253 fn c241_l253_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c241_l253_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1994,7 +2956,13 @@ fn c241_l253_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 254 fn c242_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c242_l254_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2002,7 +2970,13 @@ fn c242_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 255 fn c243_l255_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c243_l255_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2010,7 +2984,13 @@ fn c243_l255_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 256 fn c244_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c244_l256_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2018,7 +2998,13 @@ fn c244_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 257 fn c245_l257_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c245_l257_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2026,7 +3012,13 @@ fn c245_l257_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 258 fn c246_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c246_l258_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2034,7 +3026,13 @@ fn c246_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 259 fn c247_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c247_l259_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2042,7 +3040,13 @@ fn c247_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 260 fn c248_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c248_l260_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2050,7 +3054,13 @@ fn c248_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 261 fn c249_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c249_l261_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2058,7 +3068,13 @@ fn c249_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 262 fn c250_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c250_l262_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2066,7 +3082,13 @@ fn c250_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 263 fn c251_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c251_l263_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2074,7 +3096,13 @@ fn c251_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 264 fn c252_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c252_l264_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2082,7 +3110,13 @@ fn c252_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 265 fn c253_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c253_l265_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2090,7 +3124,13 @@ fn c253_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 266 fn c254_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c254_l266_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2098,7 +3138,13 @@ fn c254_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 267 fn c255_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c255_l267_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2106,7 +3152,13 @@ fn c255_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 268 fn c256_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c256_l268_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2114,7 +3166,13 @@ fn c256_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 269 fn c257_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c257_l269_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2122,7 +3180,13 @@ fn c257_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 270 fn c258_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c258_l270_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2130,7 +3194,13 @@ fn c258_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 271 fn c259_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c259_l271_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2138,7 +3208,13 @@ fn c259_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 272 fn c260_l272_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c260_l272_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2146,7 +3222,13 @@ fn c260_l272_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 273 fn c261_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c261_l273_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2154,7 +3236,13 @@ fn c261_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 274 fn c262_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c262_l274_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2162,7 +3250,13 @@ fn c262_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 275 fn c263_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c263_l275_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2170,7 +3264,13 @@ fn c263_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 276 fn c264_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c264_l276_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2178,7 +3278,13 @@ fn c264_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 277 fn c265_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c265_l277_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2186,7 +3292,13 @@ fn c265_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 278 fn c266_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c266_l278_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2194,7 +3306,13 @@ fn c266_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 279 fn c267_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c267_l279_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2202,7 +3320,13 @@ fn c267_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 280 fn c268_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c268_l280_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2210,7 +3334,13 @@ fn c268_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 281 fn c269_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c269_l281_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2218,7 +3348,13 @@ fn c269_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 282 fn c270_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c270_l282_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2226,7 +3362,13 @@ fn c270_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 283 fn c271_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c271_l283_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2234,7 +3376,13 @@ fn c271_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 284 fn c272_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c272_l284_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2242,7 +3390,13 @@ fn c272_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 285 fn c273_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c273_l285_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2250,7 +3404,13 @@ fn c273_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 286 fn c274_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c274_l286_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2258,7 +3418,13 @@ fn c274_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 287 fn c275_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c275_l287_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2266,7 +3432,13 @@ fn c275_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 288 fn c276_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c276_l288_action_invoke"); - let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2274,7 +3446,13 @@ fn c276_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 289 fn c277_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c277_l289_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2282,7 +3460,13 @@ fn c277_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 290 fn c278_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c278_l290_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2290,7 +3474,13 @@ fn c278_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 291 fn c279_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c279_l291_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2298,7 +3488,13 @@ fn c279_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 292 fn c280_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c280_l292_action_invoke"); - let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2306,7 +3502,10 @@ fn c280_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 293 fn c281_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c281_l293_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2338,7 +3537,13 @@ fn c284_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 297 fn c285_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c285_l297_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2346,7 +3551,13 @@ fn c285_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 298 fn c286_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c286_l298_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2354,7 +3565,13 @@ fn c286_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 299 fn c287_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c287_l299_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2362,7 +3579,13 @@ fn c287_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 300 fn c288_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c288_l300_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2370,7 +3593,13 @@ fn c288_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 301 fn c289_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c289_l301_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2378,7 +3607,13 @@ fn c289_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 302 fn c290_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c290_l302_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2386,7 +3621,13 @@ fn c290_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 303 fn c291_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c291_l303_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2394,7 +3635,13 @@ fn c291_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 304 fn c292_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c292_l304_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2402,7 +3649,10 @@ fn c292_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 305 fn c293_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c293_l305_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2434,7 +3684,10 @@ fn c296_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 309 fn c297_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c297_l309_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2466,7 +3719,10 @@ fn c300_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 313 fn c301_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c301_l313_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2474,7 +3730,10 @@ fn c301_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 314 fn c302_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c302_l314_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2482,7 +3741,10 @@ fn c302_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 315 fn c303_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c303_l315_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2490,7 +3752,10 @@ fn c303_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 316 fn c304_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c304_l316_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2498,7 +3763,13 @@ fn c304_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 317 fn c305_l317_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c305_l317_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2506,7 +3777,13 @@ fn c305_l317_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 318 fn c306_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c306_l318_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2514,7 +3791,13 @@ fn c306_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 319 fn c307_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c307_l319_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2522,7 +3805,13 @@ fn c307_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 320 fn c308_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c308_l320_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2530,7 +3819,10 @@ fn c308_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 321 fn c309_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c309_l321_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2538,7 +3830,10 @@ fn c309_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 322 fn c310_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c310_l322_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "eq", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2546,7 +3841,10 @@ fn c310_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 323 fn c311_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c311_l323_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2554,7 +3852,10 @@ fn c311_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 324 fn c312_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c312_l324_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "eq", + &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2562,7 +3863,13 @@ fn c312_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 325 fn c313_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c313_l325_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2570,7 +3877,13 @@ fn c313_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 326 fn c314_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c314_l326_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2578,7 +3891,13 @@ fn c314_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 327 fn c315_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c315_l327_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2586,7 +3905,13 @@ fn c315_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 328 fn c316_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c316_l328_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2594,7 +3919,13 @@ fn c316_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 329 fn c317_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c317_l329_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2602,7 +3933,13 @@ fn c317_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 330 fn c318_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c318_l330_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2610,7 +3947,13 @@ fn c318_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 331 fn c319_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c319_l331_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2618,7 +3961,13 @@ fn c319_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 332 fn c320_l332_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c320_l332_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2626,7 +3975,13 @@ fn c320_l332_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 333 fn c321_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c321_l333_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2634,7 +3989,13 @@ fn c321_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 334 fn c322_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c322_l334_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2642,7 +4003,10 @@ fn c322_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 335 fn c323_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c323_l335_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2650,7 +4014,10 @@ fn c323_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 336 fn c324_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c324_l336_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2658,7 +4025,13 @@ fn c324_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 337 fn c325_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c325_l337_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2666,7 +4039,13 @@ fn c325_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 338 fn c326_l338_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c326_l338_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2674,7 +4053,10 @@ fn c326_l338_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 339 fn c327_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c327_l339_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2682,7 +4064,10 @@ fn c327_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 340 fn c328_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c328_l340_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2690,7 +4075,13 @@ fn c328_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 341 fn c329_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c329_l341_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2698,7 +4089,13 @@ fn c329_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 342 fn c330_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c330_l342_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2706,7 +4103,13 @@ fn c330_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 343 fn c331_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c331_l343_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2714,7 +4117,13 @@ fn c331_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 344 fn c332_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c332_l344_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2722,7 +4131,13 @@ fn c332_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 345 fn c333_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c333_l345_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2730,7 +4145,13 @@ fn c333_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 346 fn c334_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c334_l346_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2738,7 +4159,13 @@ fn c334_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 347 fn c335_l347_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c335_l347_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2746,7 +4173,13 @@ fn c335_l347_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 348 fn c336_l348_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c336_l348_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2754,7 +4187,13 @@ fn c336_l348_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 349 fn c337_l349_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c337_l349_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2762,7 +4201,13 @@ fn c337_l349_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 350 fn c338_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c338_l350_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2770,7 +4215,13 @@ fn c338_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 351 fn c339_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c339_l351_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2778,7 +4229,13 @@ fn c339_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 352 fn c340_l352_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c340_l352_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2786,7 +4243,13 @@ fn c340_l352_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 353 fn c341_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c341_l353_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2794,7 +4257,13 @@ fn c341_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 354 fn c342_l354_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c342_l354_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2802,7 +4271,13 @@ fn c342_l354_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 355 fn c343_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c343_l355_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2810,7 +4285,13 @@ fn c343_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 356 fn c344_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c344_l356_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2818,7 +4299,13 @@ fn c344_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 357 fn c345_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c345_l357_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2826,7 +4313,13 @@ fn c345_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 358 fn c346_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c346_l358_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2834,7 +4327,10 @@ fn c346_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 359 fn c347_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c347_l359_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2842,7 +4338,10 @@ fn c347_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 360 fn c348_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c348_l360_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2850,7 +4349,13 @@ fn c348_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 361 fn c349_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c349_l361_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2858,7 +4363,13 @@ fn c349_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 362 fn c350_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c350_l362_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2866,7 +4377,10 @@ fn c350_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 363 fn c351_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c351_l363_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2874,7 +4388,10 @@ fn c351_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 364 fn c352_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c352_l364_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2882,7 +4399,13 @@ fn c352_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 365 fn c353_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c353_l365_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2890,7 +4413,13 @@ fn c353_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 366 fn c354_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c354_l366_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2898,7 +4427,10 @@ fn c354_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 367 fn c355_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c355_l367_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2906,7 +4438,10 @@ fn c355_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 368 fn c356_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c356_l368_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2914,7 +4449,13 @@ fn c356_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 369 fn c357_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c357_l369_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2922,7 +4463,13 @@ fn c357_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 370 fn c358_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c358_l370_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2930,7 +4477,10 @@ fn c358_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 371 fn c359_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c359_l371_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2938,7 +4488,10 @@ fn c359_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 372 fn c360_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c360_l372_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]); + let result = instance.call( + "eq", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2946,7 +4499,13 @@ fn c360_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 373 fn c361_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c361_l373_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2954,7 +4513,13 @@ fn c361_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 374 fn c362_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c362_l374_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2962,7 +4527,13 @@ fn c362_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 375 fn c363_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c363_l375_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2970,7 +4541,13 @@ fn c363_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 376 fn c364_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c364_l376_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2978,7 +4555,13 @@ fn c364_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 377 fn c365_l377_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c365_l377_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2986,7 +4569,13 @@ fn c365_l377_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 378 fn c366_l378_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c366_l378_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2994,7 +4583,13 @@ fn c366_l378_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 379 fn c367_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c367_l379_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3002,7 +4597,13 @@ fn c367_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 380 fn c368_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c368_l380_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3010,7 +4611,13 @@ fn c368_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 381 fn c369_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c369_l381_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3018,7 +4625,13 @@ fn c369_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 382 fn c370_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c370_l382_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3026,7 +4639,13 @@ fn c370_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 383 fn c371_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c371_l383_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3034,7 +4653,13 @@ fn c371_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 384 fn c372_l384_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c372_l384_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3042,7 +4667,13 @@ fn c372_l384_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 385 fn c373_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c373_l385_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3050,7 +4681,13 @@ fn c373_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 386 fn c374_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c374_l386_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3058,7 +4695,13 @@ fn c374_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 387 fn c375_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c375_l387_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3066,7 +4709,13 @@ fn c375_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 388 fn c376_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c376_l388_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3074,7 +4723,13 @@ fn c376_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 389 fn c377_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c377_l389_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3082,7 +4737,13 @@ fn c377_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 390 fn c378_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c378_l390_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3090,7 +4751,13 @@ fn c378_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 391 fn c379_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c379_l391_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3098,7 +4765,13 @@ fn c379_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 392 fn c380_l392_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c380_l392_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3106,7 +4779,13 @@ fn c380_l392_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 393 fn c381_l393_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c381_l393_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3114,7 +4793,13 @@ fn c381_l393_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 394 fn c382_l394_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c382_l394_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3122,7 +4807,13 @@ fn c382_l394_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 395 fn c383_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c383_l395_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3130,7 +4821,13 @@ fn c383_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 396 fn c384_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c384_l396_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3138,7 +4835,13 @@ fn c384_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 397 fn c385_l397_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c385_l397_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3146,7 +4849,13 @@ fn c385_l397_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 398 fn c386_l398_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c386_l398_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3154,7 +4863,13 @@ fn c386_l398_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 399 fn c387_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c387_l399_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3162,7 +4877,13 @@ fn c387_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 400 fn c388_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c388_l400_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3170,7 +4891,13 @@ fn c388_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 401 fn c389_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c389_l401_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3178,7 +4905,13 @@ fn c389_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 402 fn c390_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c390_l402_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3186,7 +4919,13 @@ fn c390_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 403 fn c391_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c391_l403_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3194,7 +4933,13 @@ fn c391_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 404 fn c392_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c392_l404_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3202,7 +4947,13 @@ fn c392_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 405 fn c393_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c393_l405_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3210,7 +4961,13 @@ fn c393_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 406 fn c394_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c394_l406_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3218,7 +4975,13 @@ fn c394_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 407 fn c395_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c395_l407_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3226,7 +4989,13 @@ fn c395_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 408 fn c396_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c396_l408_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3234,7 +5003,13 @@ fn c396_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 409 fn c397_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c397_l409_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3242,7 +5017,13 @@ fn c397_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 410 fn c398_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c398_l410_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3250,7 +5031,13 @@ fn c398_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 411 fn c399_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c399_l411_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3258,7 +5045,13 @@ fn c399_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 412 fn c400_l412_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c400_l412_action_invoke"); - let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "eq", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3298,7 +5091,13 @@ fn c404_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 417 fn c405_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c405_l417_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3306,7 +5105,13 @@ fn c405_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 418 fn c406_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c406_l418_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3314,7 +5119,13 @@ fn c406_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 419 fn c407_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c407_l419_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3322,7 +5133,13 @@ fn c407_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 420 fn c408_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c408_l420_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3330,7 +5147,13 @@ fn c408_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 421 fn c409_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c409_l421_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3338,7 +5161,13 @@ fn c409_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 422 fn c410_l422_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c410_l422_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3346,7 +5175,13 @@ fn c410_l422_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 423 fn c411_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c411_l423_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3354,7 +5189,13 @@ fn c411_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 424 fn c412_l424_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c412_l424_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3458,7 +5299,13 @@ fn c424_l436_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 437 fn c425_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c425_l437_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3466,7 +5313,13 @@ fn c425_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 438 fn c426_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c426_l438_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3474,7 +5327,13 @@ fn c426_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 439 fn c427_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c427_l439_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3482,7 +5341,13 @@ fn c427_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 440 fn c428_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c428_l440_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3490,7 +5355,10 @@ fn c428_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 441 fn c429_l441_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c429_l441_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3522,7 +5390,13 @@ fn c432_l444_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 445 fn c433_l445_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c433_l445_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3530,7 +5404,13 @@ fn c433_l445_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 446 fn c434_l446_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c434_l446_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3538,7 +5418,13 @@ fn c434_l446_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 447 fn c435_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c435_l447_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3546,7 +5432,13 @@ fn c435_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 448 fn c436_l448_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c436_l448_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3554,7 +5446,10 @@ fn c436_l448_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 449 fn c437_l449_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c437_l449_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3562,7 +5457,10 @@ fn c437_l449_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 450 fn c438_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c438_l450_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3570,7 +5468,10 @@ fn c438_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 451 fn c439_l451_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c439_l451_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3578,7 +5479,10 @@ fn c439_l451_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 452 fn c440_l452_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c440_l452_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3586,7 +5490,13 @@ fn c440_l452_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 453 fn c441_l453_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c441_l453_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3594,7 +5504,13 @@ fn c441_l453_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 454 fn c442_l454_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c442_l454_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3602,7 +5518,13 @@ fn c442_l454_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 455 fn c443_l455_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c443_l455_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3610,7 +5532,13 @@ fn c443_l455_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 456 fn c444_l456_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c444_l456_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3618,7 +5546,13 @@ fn c444_l456_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 457 fn c445_l457_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c445_l457_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3626,7 +5560,13 @@ fn c445_l457_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 458 fn c446_l458_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c446_l458_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3634,7 +5574,13 @@ fn c446_l458_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 459 fn c447_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c447_l459_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3642,7 +5588,13 @@ fn c447_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 460 fn c448_l460_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c448_l460_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3650,7 +5602,13 @@ fn c448_l460_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 461 fn c449_l461_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c449_l461_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3658,7 +5616,13 @@ fn c449_l461_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 462 fn c450_l462_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c450_l462_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3666,7 +5630,13 @@ fn c450_l462_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 463 fn c451_l463_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c451_l463_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3674,7 +5644,13 @@ fn c451_l463_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 464 fn c452_l464_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c452_l464_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3682,7 +5658,13 @@ fn c452_l464_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 465 fn c453_l465_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c453_l465_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3690,7 +5672,13 @@ fn c453_l465_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 466 fn c454_l466_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c454_l466_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3698,7 +5686,13 @@ fn c454_l466_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 467 fn c455_l467_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c455_l467_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3706,7 +5700,13 @@ fn c455_l467_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 468 fn c456_l468_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c456_l468_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3714,7 +5714,13 @@ fn c456_l468_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 469 fn c457_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c457_l469_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3722,7 +5728,13 @@ fn c457_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 470 fn c458_l470_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c458_l470_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3730,7 +5742,13 @@ fn c458_l470_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 471 fn c459_l471_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c459_l471_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3738,7 +5756,13 @@ fn c459_l471_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 472 fn c460_l472_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c460_l472_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3746,7 +5770,13 @@ fn c460_l472_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 473 fn c461_l473_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c461_l473_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3754,7 +5784,13 @@ fn c461_l473_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 474 fn c462_l474_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c462_l474_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3762,7 +5798,13 @@ fn c462_l474_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 475 fn c463_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c463_l475_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3770,7 +5812,13 @@ fn c463_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 476 fn c464_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c464_l476_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3778,7 +5826,13 @@ fn c464_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 477 fn c465_l477_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c465_l477_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3786,7 +5840,13 @@ fn c465_l477_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 478 fn c466_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c466_l478_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3794,7 +5854,13 @@ fn c466_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 479 fn c467_l479_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c467_l479_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3802,7 +5868,13 @@ fn c467_l479_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 480 fn c468_l480_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c468_l480_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3810,7 +5882,13 @@ fn c468_l480_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 481 fn c469_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c469_l481_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3818,7 +5896,13 @@ fn c469_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 482 fn c470_l482_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c470_l482_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3826,7 +5910,13 @@ fn c470_l482_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 483 fn c471_l483_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c471_l483_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3834,7 +5924,13 @@ fn c471_l483_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 484 fn c472_l484_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c472_l484_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3842,7 +5938,13 @@ fn c472_l484_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 485 fn c473_l485_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c473_l485_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3850,7 +5952,13 @@ fn c473_l485_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 486 fn c474_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c474_l486_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3858,7 +5966,13 @@ fn c474_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 487 fn c475_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c475_l487_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3866,7 +5980,13 @@ fn c475_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 488 fn c476_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c476_l488_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3874,7 +5994,13 @@ fn c476_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 489 fn c477_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c477_l489_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3882,7 +6008,13 @@ fn c477_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 490 fn c478_l490_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c478_l490_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3890,7 +6022,13 @@ fn c478_l490_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 491 fn c479_l491_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c479_l491_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3898,7 +6036,13 @@ fn c479_l491_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 492 fn c480_l492_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c480_l492_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3906,7 +6050,13 @@ fn c480_l492_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 493 fn c481_l493_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c481_l493_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3914,7 +6064,13 @@ fn c481_l493_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 494 fn c482_l494_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c482_l494_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3922,7 +6078,13 @@ fn c482_l494_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 495 fn c483_l495_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c483_l495_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3930,7 +6092,13 @@ fn c483_l495_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 496 fn c484_l496_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c484_l496_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3938,7 +6106,13 @@ fn c484_l496_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 497 fn c485_l497_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c485_l497_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3946,7 +6120,13 @@ fn c485_l497_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 498 fn c486_l498_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c486_l498_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3954,7 +6134,13 @@ fn c486_l498_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 499 fn c487_l499_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c487_l499_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3962,7 +6148,13 @@ fn c487_l499_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 500 fn c488_l500_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c488_l500_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3970,7 +6162,13 @@ fn c488_l500_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 501 fn c489_l501_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c489_l501_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3978,7 +6176,13 @@ fn c489_l501_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 502 fn c490_l502_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c490_l502_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3986,7 +6190,13 @@ fn c490_l502_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 503 fn c491_l503_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c491_l503_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3994,7 +6204,13 @@ fn c491_l503_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 504 fn c492_l504_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c492_l504_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -4002,7 +6218,13 @@ fn c492_l504_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 505 fn c493_l505_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c493_l505_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4010,7 +6232,13 @@ fn c493_l505_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 506 fn c494_l506_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c494_l506_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4018,7 +6246,13 @@ fn c494_l506_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 507 fn c495_l507_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c495_l507_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4026,7 +6260,13 @@ fn c495_l507_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 508 fn c496_l508_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c496_l508_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4034,7 +6274,13 @@ fn c496_l508_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 509 fn c497_l509_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c497_l509_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4042,7 +6288,13 @@ fn c497_l509_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 510 fn c498_l510_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c498_l510_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4050,7 +6302,13 @@ fn c498_l510_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 511 fn c499_l511_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c499_l511_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4058,7 +6316,13 @@ fn c499_l511_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 512 fn c500_l512_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c500_l512_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4066,7 +6330,13 @@ fn c500_l512_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 513 fn c501_l513_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c501_l513_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4074,7 +6344,13 @@ fn c501_l513_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 514 fn c502_l514_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c502_l514_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4082,7 +6358,13 @@ fn c502_l514_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 515 fn c503_l515_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c503_l515_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4090,7 +6372,13 @@ fn c503_l515_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 516 fn c504_l516_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c504_l516_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4098,7 +6386,13 @@ fn c504_l516_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 517 fn c505_l517_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c505_l517_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4106,7 +6400,13 @@ fn c505_l517_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 518 fn c506_l518_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c506_l518_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4114,7 +6414,13 @@ fn c506_l518_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 519 fn c507_l519_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c507_l519_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4122,7 +6428,13 @@ fn c507_l519_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 520 fn c508_l520_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c508_l520_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4130,7 +6442,13 @@ fn c508_l520_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 521 fn c509_l521_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c509_l521_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4138,7 +6456,13 @@ fn c509_l521_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 522 fn c510_l522_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c510_l522_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4146,7 +6470,13 @@ fn c510_l522_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 523 fn c511_l523_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c511_l523_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4154,7 +6484,13 @@ fn c511_l523_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 524 fn c512_l524_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c512_l524_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4162,7 +6498,13 @@ fn c512_l524_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 525 fn c513_l525_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c513_l525_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4170,7 +6512,13 @@ fn c513_l525_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 526 fn c514_l526_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c514_l526_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4178,7 +6526,13 @@ fn c514_l526_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 527 fn c515_l527_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c515_l527_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4186,7 +6540,13 @@ fn c515_l527_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 528 fn c516_l528_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c516_l528_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4194,7 +6554,13 @@ fn c516_l528_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 529 fn c517_l529_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c517_l529_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4202,7 +6568,13 @@ fn c517_l529_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 530 fn c518_l530_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c518_l530_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4210,7 +6582,13 @@ fn c518_l530_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 531 fn c519_l531_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c519_l531_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4218,7 +6596,13 @@ fn c519_l531_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 532 fn c520_l532_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c520_l532_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4258,7 +6642,13 @@ fn c524_l536_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 537 fn c525_l537_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c525_l537_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4266,7 +6656,13 @@ fn c525_l537_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 538 fn c526_l538_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c526_l538_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4274,7 +6670,13 @@ fn c526_l538_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 539 fn c527_l539_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c527_l539_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4282,7 +6684,13 @@ fn c527_l539_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 540 fn c528_l540_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c528_l540_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4290,7 +6698,13 @@ fn c528_l540_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 541 fn c529_l541_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c529_l541_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4298,7 +6712,13 @@ fn c529_l541_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 542 fn c530_l542_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c530_l542_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4306,7 +6726,13 @@ fn c530_l542_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 543 fn c531_l543_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c531_l543_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4314,7 +6740,13 @@ fn c531_l543_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 544 fn c532_l544_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c532_l544_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4418,7 +6850,13 @@ fn c544_l556_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 557 fn c545_l557_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c545_l557_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4426,7 +6864,13 @@ fn c545_l557_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 558 fn c546_l558_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c546_l558_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4434,7 +6878,13 @@ fn c546_l558_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 559 fn c547_l559_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c547_l559_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4442,7 +6892,13 @@ fn c547_l559_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 560 fn c548_l560_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c548_l560_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4450,7 +6906,10 @@ fn c548_l560_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 561 fn c549_l561_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c549_l561_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4482,7 +6941,13 @@ fn c552_l564_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 565 fn c553_l565_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c553_l565_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4490,7 +6955,13 @@ fn c553_l565_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 566 fn c554_l566_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c554_l566_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4498,7 +6969,13 @@ fn c554_l566_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 567 fn c555_l567_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c555_l567_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4506,7 +6983,13 @@ fn c555_l567_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 568 fn c556_l568_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c556_l568_action_invoke"); - let result = instance.call("ne", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4514,7 +6997,10 @@ fn c556_l568_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 569 fn c557_l569_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c557_l569_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4522,7 +7008,10 @@ fn c557_l569_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 570 fn c558_l570_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c558_l570_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4530,7 +7019,10 @@ fn c558_l570_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 571 fn c559_l571_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c559_l571_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4538,7 +7030,10 @@ fn c559_l571_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 572 fn c560_l572_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c560_l572_action_invoke"); - let result = instance.call("ne", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4578,7 +7073,13 @@ fn c564_l576_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 577 fn c565_l577_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c565_l577_action_invoke"); - let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4586,7 +7087,13 @@ fn c565_l577_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 578 fn c566_l578_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c566_l578_action_invoke"); - let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4594,7 +7101,13 @@ fn c566_l578_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 579 fn c567_l579_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c567_l579_action_invoke"); - let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4602,7 +7115,13 @@ fn c567_l579_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 580 fn c568_l580_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c568_l580_action_invoke"); - let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4610,7 +7129,13 @@ fn c568_l580_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 581 fn c569_l581_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c569_l581_action_invoke"); - let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4618,7 +7143,13 @@ fn c569_l581_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 582 fn c570_l582_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c570_l582_action_invoke"); - let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4626,7 +7157,13 @@ fn c570_l582_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 583 fn c571_l583_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c571_l583_action_invoke"); - let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4634,7 +7171,13 @@ fn c571_l583_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 584 fn c572_l584_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c572_l584_action_invoke"); - let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4738,7 +7281,13 @@ fn c584_l596_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 597 fn c585_l597_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c585_l597_action_invoke"); - let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4746,7 +7295,13 @@ fn c585_l597_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 598 fn c586_l598_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c586_l598_action_invoke"); - let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4754,7 +7309,13 @@ fn c586_l598_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 599 fn c587_l599_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c587_l599_action_invoke"); - let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4762,7 +7323,13 @@ fn c587_l599_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 600 fn c588_l600_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c588_l600_action_invoke"); - let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4770,7 +7337,10 @@ fn c588_l600_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 601 fn c589_l601_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c589_l601_action_invoke"); - let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4802,7 +7372,13 @@ fn c592_l604_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 605 fn c593_l605_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c593_l605_action_invoke"); - let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4810,7 +7386,13 @@ fn c593_l605_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 606 fn c594_l606_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c594_l606_action_invoke"); - let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4818,7 +7400,13 @@ fn c594_l606_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 607 fn c595_l607_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c595_l607_action_invoke"); - let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4826,7 +7414,13 @@ fn c595_l607_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 608 fn c596_l608_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c596_l608_action_invoke"); - let result = instance.call("ne", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4834,7 +7428,10 @@ fn c596_l608_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 609 fn c597_l609_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c597_l609_action_invoke"); - let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4842,7 +7439,10 @@ fn c597_l609_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 610 fn c598_l610_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c598_l610_action_invoke"); - let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4850,7 +7450,10 @@ fn c598_l610_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 611 fn c599_l611_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c599_l611_action_invoke"); - let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4858,7 +7461,10 @@ fn c599_l611_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 612 fn c600_l612_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c600_l612_action_invoke"); - let result = instance.call("ne", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4898,7 +7504,13 @@ fn c604_l616_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 617 fn c605_l617_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c605_l617_action_invoke"); - let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4906,7 +7518,13 @@ fn c605_l617_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 618 fn c606_l618_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c606_l618_action_invoke"); - let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4914,7 +7532,13 @@ fn c606_l618_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 619 fn c607_l619_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c607_l619_action_invoke"); - let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4922,7 +7546,13 @@ fn c607_l619_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 620 fn c608_l620_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c608_l620_action_invoke"); - let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4930,7 +7560,13 @@ fn c608_l620_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 621 fn c609_l621_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c609_l621_action_invoke"); - let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4938,7 +7574,13 @@ fn c609_l621_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 622 fn c610_l622_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c610_l622_action_invoke"); - let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4946,7 +7588,13 @@ fn c610_l622_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 623 fn c611_l623_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c611_l623_action_invoke"); - let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4954,7 +7602,13 @@ fn c611_l623_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 624 fn c612_l624_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c612_l624_action_invoke"); - let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5026,7 +7680,10 @@ fn c620_l632_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 633 fn c621_l633_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c621_l633_action_invoke"); - let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ne", + &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -5034,7 +7691,10 @@ fn c621_l633_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 634 fn c622_l634_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c622_l634_action_invoke"); - let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ne", + &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5042,7 +7702,10 @@ fn c622_l634_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 635 fn c623_l635_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c623_l635_action_invoke"); - let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ne", + &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5050,7 +7713,10 @@ fn c623_l635_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 636 fn c624_l636_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c624_l636_action_invoke"); - let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ne", + &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -5058,7 +7724,13 @@ fn c624_l636_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 637 fn c625_l637_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c625_l637_action_invoke"); - let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5066,7 +7738,13 @@ fn c625_l637_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 638 fn c626_l638_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c626_l638_action_invoke"); - let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5074,7 +7752,13 @@ fn c626_l638_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 639 fn c627_l639_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c627_l639_action_invoke"); - let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5082,7 +7766,13 @@ fn c627_l639_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 640 fn c628_l640_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c628_l640_action_invoke"); - let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5090,7 +7780,10 @@ fn c628_l640_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 641 fn c629_l641_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c629_l641_action_invoke"); - let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5098,7 +7791,10 @@ fn c629_l641_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 642 fn c630_l642_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c630_l642_action_invoke"); - let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ne", + &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5106,7 +7802,10 @@ fn c630_l642_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 643 fn c631_l643_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c631_l643_action_invoke"); - let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5114,7 +7813,10 @@ fn c631_l643_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 644 fn c632_l644_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c632_l644_action_invoke"); - let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ne", + &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5122,7 +7824,13 @@ fn c632_l644_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 645 fn c633_l645_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c633_l645_action_invoke"); - let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5130,7 +7838,13 @@ fn c633_l645_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 646 fn c634_l646_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c634_l646_action_invoke"); - let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5138,7 +7852,13 @@ fn c634_l646_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 647 fn c635_l647_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c635_l647_action_invoke"); - let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5146,7 +7866,13 @@ fn c635_l647_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 648 fn c636_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c636_l648_action_invoke"); - let result = instance.call("ne", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5154,7 +7880,13 @@ fn c636_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 649 fn c637_l649_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c637_l649_action_invoke"); - let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5162,7 +7894,13 @@ fn c637_l649_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 650 fn c638_l650_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c638_l650_action_invoke"); - let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5170,7 +7908,13 @@ fn c638_l650_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 651 fn c639_l651_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c639_l651_action_invoke"); - let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5178,7 +7922,13 @@ fn c639_l651_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 652 fn c640_l652_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c640_l652_action_invoke"); - let result = instance.call("ne", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5186,7 +7936,13 @@ fn c640_l652_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 653 fn c641_l653_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c641_l653_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5194,7 +7950,13 @@ fn c641_l653_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 654 fn c642_l654_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c642_l654_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5202,7 +7964,13 @@ fn c642_l654_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 655 fn c643_l655_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c643_l655_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5210,7 +7978,13 @@ fn c643_l655_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 656 fn c644_l656_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c644_l656_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5218,7 +7992,13 @@ fn c644_l656_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 657 fn c645_l657_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c645_l657_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5226,7 +8006,13 @@ fn c645_l657_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 658 fn c646_l658_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c646_l658_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5234,7 +8020,13 @@ fn c646_l658_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 659 fn c647_l659_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c647_l659_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5242,7 +8034,13 @@ fn c647_l659_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 660 fn c648_l660_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c648_l660_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5250,7 +8048,13 @@ fn c648_l660_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 661 fn c649_l661_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c649_l661_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5258,7 +8062,13 @@ fn c649_l661_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 662 fn c650_l662_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c650_l662_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5266,7 +8076,13 @@ fn c650_l662_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 663 fn c651_l663_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c651_l663_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5274,7 +8090,13 @@ fn c651_l663_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 664 fn c652_l664_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c652_l664_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5282,7 +8104,13 @@ fn c652_l664_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 665 fn c653_l665_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c653_l665_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5290,7 +8118,13 @@ fn c653_l665_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 666 fn c654_l666_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c654_l666_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5298,7 +8132,13 @@ fn c654_l666_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 667 fn c655_l667_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c655_l667_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5306,7 +8146,13 @@ fn c655_l667_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 668 fn c656_l668_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c656_l668_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5314,7 +8160,13 @@ fn c656_l668_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 669 fn c657_l669_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c657_l669_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5322,7 +8174,13 @@ fn c657_l669_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 670 fn c658_l670_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c658_l670_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5330,7 +8188,13 @@ fn c658_l670_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 671 fn c659_l671_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c659_l671_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5338,7 +8202,13 @@ fn c659_l671_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 672 fn c660_l672_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c660_l672_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5346,7 +8216,13 @@ fn c660_l672_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 673 fn c661_l673_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c661_l673_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5354,7 +8230,13 @@ fn c661_l673_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 674 fn c662_l674_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c662_l674_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5362,7 +8244,13 @@ fn c662_l674_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 675 fn c663_l675_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c663_l675_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5370,7 +8258,13 @@ fn c663_l675_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 676 fn c664_l676_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c664_l676_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5378,7 +8272,13 @@ fn c664_l676_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 677 fn c665_l677_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c665_l677_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -5386,7 +8286,13 @@ fn c665_l677_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 678 fn c666_l678_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c666_l678_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5394,7 +8300,13 @@ fn c666_l678_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 679 fn c667_l679_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c667_l679_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5402,7 +8314,13 @@ fn c667_l679_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 680 fn c668_l680_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c668_l680_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -5410,7 +8328,13 @@ fn c668_l680_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 681 fn c669_l681_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c669_l681_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5418,7 +8342,13 @@ fn c669_l681_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 682 fn c670_l682_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c670_l682_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5426,7 +8356,13 @@ fn c670_l682_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 683 fn c671_l683_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c671_l683_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5434,7 +8370,13 @@ fn c671_l683_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 684 fn c672_l684_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c672_l684_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5442,7 +8384,13 @@ fn c672_l684_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 685 fn c673_l685_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c673_l685_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5450,7 +8398,13 @@ fn c673_l685_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 686 fn c674_l686_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c674_l686_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5458,7 +8412,13 @@ fn c674_l686_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 687 fn c675_l687_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c675_l687_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5466,7 +8426,13 @@ fn c675_l687_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 688 fn c676_l688_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c676_l688_action_invoke"); - let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5474,7 +8440,13 @@ fn c676_l688_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 689 fn c677_l689_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c677_l689_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5482,7 +8454,13 @@ fn c677_l689_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 690 fn c678_l690_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c678_l690_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5490,7 +8468,13 @@ fn c678_l690_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 691 fn c679_l691_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c679_l691_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5498,7 +8482,13 @@ fn c679_l691_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 692 fn c680_l692_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c680_l692_action_invoke"); - let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5506,7 +8496,10 @@ fn c680_l692_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 693 fn c681_l693_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c681_l693_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5538,7 +8531,13 @@ fn c684_l696_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 697 fn c685_l697_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c685_l697_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5546,7 +8545,13 @@ fn c685_l697_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 698 fn c686_l698_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c686_l698_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5554,7 +8559,13 @@ fn c686_l698_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 699 fn c687_l699_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c687_l699_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5562,7 +8573,13 @@ fn c687_l699_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 700 fn c688_l700_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c688_l700_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5570,7 +8587,13 @@ fn c688_l700_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 701 fn c689_l701_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c689_l701_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5578,7 +8601,13 @@ fn c689_l701_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 702 fn c690_l702_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c690_l702_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5586,7 +8615,13 @@ fn c690_l702_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 703 fn c691_l703_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c691_l703_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5594,7 +8629,13 @@ fn c691_l703_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 704 fn c692_l704_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c692_l704_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5602,7 +8643,10 @@ fn c692_l704_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 705 fn c693_l705_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c693_l705_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5634,7 +8678,10 @@ fn c696_l708_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 709 fn c697_l709_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c697_l709_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5666,7 +8713,10 @@ fn c700_l712_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 713 fn c701_l713_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c701_l713_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5674,7 +8724,10 @@ fn c701_l713_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 714 fn c702_l714_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c702_l714_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5682,7 +8735,10 @@ fn c702_l714_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 715 fn c703_l715_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c703_l715_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5690,7 +8746,10 @@ fn c703_l715_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 716 fn c704_l716_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c704_l716_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5698,7 +8757,13 @@ fn c704_l716_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 717 fn c705_l717_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c705_l717_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5706,7 +8771,13 @@ fn c705_l717_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 718 fn c706_l718_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c706_l718_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5714,7 +8785,13 @@ fn c706_l718_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 719 fn c707_l719_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c707_l719_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5722,7 +8799,13 @@ fn c707_l719_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 720 fn c708_l720_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c708_l720_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5730,7 +8813,10 @@ fn c708_l720_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 721 fn c709_l721_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c709_l721_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -5738,7 +8824,10 @@ fn c709_l721_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 722 fn c710_l722_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c710_l722_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ne", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5746,7 +8835,10 @@ fn c710_l722_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 723 fn c711_l723_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c711_l723_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5754,7 +8846,10 @@ fn c711_l723_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 724 fn c712_l724_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c712_l724_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ne", + &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -5762,7 +8857,13 @@ fn c712_l724_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 725 fn c713_l725_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c713_l725_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5770,7 +8871,13 @@ fn c713_l725_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 726 fn c714_l726_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c714_l726_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5778,7 +8885,13 @@ fn c714_l726_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 727 fn c715_l727_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c715_l727_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5786,7 +8899,13 @@ fn c715_l727_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 728 fn c716_l728_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c716_l728_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5794,7 +8913,13 @@ fn c716_l728_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 729 fn c717_l729_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c717_l729_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5802,7 +8927,13 @@ fn c717_l729_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 730 fn c718_l730_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c718_l730_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5810,7 +8941,13 @@ fn c718_l730_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 731 fn c719_l731_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c719_l731_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5818,7 +8955,13 @@ fn c719_l731_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 732 fn c720_l732_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c720_l732_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5826,7 +8969,13 @@ fn c720_l732_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 733 fn c721_l733_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c721_l733_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5834,7 +8983,13 @@ fn c721_l733_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 734 fn c722_l734_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c722_l734_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5842,7 +8997,10 @@ fn c722_l734_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 735 fn c723_l735_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c723_l735_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5850,7 +9008,10 @@ fn c723_l735_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 736 fn c724_l736_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c724_l736_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5858,7 +9019,13 @@ fn c724_l736_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 737 fn c725_l737_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c725_l737_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5866,7 +9033,13 @@ fn c725_l737_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 738 fn c726_l738_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c726_l738_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5874,7 +9047,10 @@ fn c726_l738_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 739 fn c727_l739_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c727_l739_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5882,7 +9058,10 @@ fn c727_l739_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 740 fn c728_l740_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c728_l740_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5890,7 +9069,13 @@ fn c728_l740_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 741 fn c729_l741_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c729_l741_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5898,7 +9083,13 @@ fn c729_l741_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 742 fn c730_l742_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c730_l742_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5906,7 +9097,13 @@ fn c730_l742_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 743 fn c731_l743_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c731_l743_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5914,7 +9111,13 @@ fn c731_l743_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 744 fn c732_l744_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c732_l744_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5922,7 +9125,13 @@ fn c732_l744_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 745 fn c733_l745_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c733_l745_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5930,7 +9139,13 @@ fn c733_l745_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 746 fn c734_l746_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c734_l746_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5938,7 +9153,13 @@ fn c734_l746_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 747 fn c735_l747_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c735_l747_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5946,7 +9167,13 @@ fn c735_l747_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 748 fn c736_l748_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c736_l748_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5954,7 +9181,13 @@ fn c736_l748_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 749 fn c737_l749_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c737_l749_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5962,7 +9195,13 @@ fn c737_l749_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 750 fn c738_l750_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c738_l750_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5970,7 +9209,13 @@ fn c738_l750_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 751 fn c739_l751_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c739_l751_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5978,7 +9223,13 @@ fn c739_l751_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 752 fn c740_l752_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c740_l752_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5986,7 +9237,13 @@ fn c740_l752_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 753 fn c741_l753_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c741_l753_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5994,7 +9251,13 @@ fn c741_l753_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 754 fn c742_l754_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c742_l754_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6002,7 +9265,13 @@ fn c742_l754_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 755 fn c743_l755_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c743_l755_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6010,7 +9279,13 @@ fn c743_l755_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 756 fn c744_l756_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c744_l756_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6018,7 +9293,13 @@ fn c744_l756_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 757 fn c745_l757_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c745_l757_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6026,7 +9307,13 @@ fn c745_l757_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 758 fn c746_l758_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c746_l758_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6034,7 +9321,10 @@ fn c746_l758_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 759 fn c747_l759_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c747_l759_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6042,7 +9332,10 @@ fn c747_l759_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 760 fn c748_l760_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c748_l760_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6050,7 +9343,13 @@ fn c748_l760_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 761 fn c749_l761_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c749_l761_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6058,7 +9357,13 @@ fn c749_l761_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 762 fn c750_l762_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c750_l762_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6066,7 +9371,10 @@ fn c750_l762_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 763 fn c751_l763_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c751_l763_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6074,7 +9382,10 @@ fn c751_l763_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 764 fn c752_l764_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c752_l764_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6082,7 +9393,13 @@ fn c752_l764_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 765 fn c753_l765_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c753_l765_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6090,7 +9407,13 @@ fn c753_l765_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 766 fn c754_l766_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c754_l766_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6098,7 +9421,10 @@ fn c754_l766_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 767 fn c755_l767_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c755_l767_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6106,7 +9432,10 @@ fn c755_l767_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 768 fn c756_l768_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c756_l768_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6114,7 +9443,13 @@ fn c756_l768_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 769 fn c757_l769_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c757_l769_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6122,7 +9457,13 @@ fn c757_l769_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 770 fn c758_l770_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c758_l770_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6130,7 +9471,10 @@ fn c758_l770_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 771 fn c759_l771_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c759_l771_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6138,7 +9482,10 @@ fn c759_l771_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 772 fn c760_l772_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c760_l772_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]); + let result = instance.call( + "ne", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6146,7 +9493,13 @@ fn c760_l772_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 773 fn c761_l773_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c761_l773_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6154,7 +9507,13 @@ fn c761_l773_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 774 fn c762_l774_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c762_l774_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6162,7 +9521,13 @@ fn c762_l774_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 775 fn c763_l775_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c763_l775_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6170,7 +9535,13 @@ fn c763_l775_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 776 fn c764_l776_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c764_l776_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6178,7 +9549,13 @@ fn c764_l776_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 777 fn c765_l777_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c765_l777_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6186,7 +9563,13 @@ fn c765_l777_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 778 fn c766_l778_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c766_l778_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6194,7 +9577,13 @@ fn c766_l778_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 779 fn c767_l779_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c767_l779_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6202,7 +9591,13 @@ fn c767_l779_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 780 fn c768_l780_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c768_l780_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6210,7 +9605,13 @@ fn c768_l780_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 781 fn c769_l781_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c769_l781_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6218,7 +9619,13 @@ fn c769_l781_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 782 fn c770_l782_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c770_l782_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6226,7 +9633,13 @@ fn c770_l782_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 783 fn c771_l783_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c771_l783_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6234,7 +9647,13 @@ fn c771_l783_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 784 fn c772_l784_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c772_l784_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6242,7 +9661,13 @@ fn c772_l784_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 785 fn c773_l785_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c773_l785_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6250,7 +9675,13 @@ fn c773_l785_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 786 fn c774_l786_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c774_l786_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6258,7 +9689,13 @@ fn c774_l786_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 787 fn c775_l787_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c775_l787_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6266,7 +9703,13 @@ fn c775_l787_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 788 fn c776_l788_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c776_l788_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6274,7 +9717,13 @@ fn c776_l788_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 789 fn c777_l789_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c777_l789_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6282,7 +9731,13 @@ fn c777_l789_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 790 fn c778_l790_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c778_l790_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6290,7 +9745,13 @@ fn c778_l790_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 791 fn c779_l791_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c779_l791_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6298,7 +9759,13 @@ fn c779_l791_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 792 fn c780_l792_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c780_l792_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6306,7 +9773,13 @@ fn c780_l792_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 793 fn c781_l793_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c781_l793_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6314,7 +9787,13 @@ fn c781_l793_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 794 fn c782_l794_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c782_l794_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6322,7 +9801,13 @@ fn c782_l794_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 795 fn c783_l795_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c783_l795_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6330,7 +9815,13 @@ fn c783_l795_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 796 fn c784_l796_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c784_l796_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6338,7 +9829,13 @@ fn c784_l796_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 797 fn c785_l797_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c785_l797_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6346,7 +9843,13 @@ fn c785_l797_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 798 fn c786_l798_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c786_l798_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6354,7 +9857,13 @@ fn c786_l798_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 799 fn c787_l799_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c787_l799_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6362,7 +9871,13 @@ fn c787_l799_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 800 fn c788_l800_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c788_l800_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6370,7 +9885,13 @@ fn c788_l800_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 801 fn c789_l801_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c789_l801_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6378,7 +9899,13 @@ fn c789_l801_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 802 fn c790_l802_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c790_l802_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6386,7 +9913,13 @@ fn c790_l802_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 803 fn c791_l803_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c791_l803_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6394,7 +9927,13 @@ fn c791_l803_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 804 fn c792_l804_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c792_l804_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6402,7 +9941,13 @@ fn c792_l804_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 805 fn c793_l805_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c793_l805_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6410,7 +9955,13 @@ fn c793_l805_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 806 fn c794_l806_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c794_l806_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6418,7 +9969,13 @@ fn c794_l806_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 807 fn c795_l807_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c795_l807_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6426,7 +9983,13 @@ fn c795_l807_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 808 fn c796_l808_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c796_l808_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6434,7 +9997,13 @@ fn c796_l808_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 809 fn c797_l809_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c797_l809_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6442,7 +10011,13 @@ fn c797_l809_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 810 fn c798_l810_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c798_l810_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6450,7 +10025,13 @@ fn c798_l810_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 811 fn c799_l811_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c799_l811_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6458,7 +10039,13 @@ fn c799_l811_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 812 fn c800_l812_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c800_l812_action_invoke"); - let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ne", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6498,7 +10085,13 @@ fn c804_l816_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 817 fn c805_l817_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c805_l817_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6506,7 +10099,13 @@ fn c805_l817_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 818 fn c806_l818_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c806_l818_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6514,7 +10113,13 @@ fn c806_l818_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 819 fn c807_l819_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c807_l819_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6522,7 +10127,13 @@ fn c807_l819_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 820 fn c808_l820_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c808_l820_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6530,7 +10141,13 @@ fn c808_l820_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 821 fn c809_l821_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c809_l821_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6538,7 +10155,13 @@ fn c809_l821_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 822 fn c810_l822_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c810_l822_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6546,7 +10169,13 @@ fn c810_l822_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 823 fn c811_l823_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c811_l823_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6554,7 +10183,13 @@ fn c811_l823_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 824 fn c812_l824_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c812_l824_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6658,7 +10293,13 @@ fn c824_l836_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 837 fn c825_l837_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c825_l837_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6666,7 +10307,13 @@ fn c825_l837_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 838 fn c826_l838_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c826_l838_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6674,7 +10321,13 @@ fn c826_l838_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 839 fn c827_l839_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c827_l839_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6682,7 +10335,13 @@ fn c827_l839_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 840 fn c828_l840_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c828_l840_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6690,7 +10349,10 @@ fn c828_l840_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 841 fn c829_l841_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c829_l841_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6722,7 +10384,13 @@ fn c832_l844_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 845 fn c833_l845_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c833_l845_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6730,7 +10398,13 @@ fn c833_l845_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 846 fn c834_l846_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c834_l846_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6738,7 +10412,13 @@ fn c834_l846_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 847 fn c835_l847_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c835_l847_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6746,7 +10426,13 @@ fn c835_l847_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 848 fn c836_l848_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c836_l848_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6754,7 +10440,10 @@ fn c836_l848_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 849 fn c837_l849_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c837_l849_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6762,7 +10451,10 @@ fn c837_l849_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 850 fn c838_l850_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c838_l850_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6770,7 +10462,10 @@ fn c838_l850_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 851 fn c839_l851_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c839_l851_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6778,7 +10473,10 @@ fn c839_l851_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 852 fn c840_l852_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c840_l852_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6786,7 +10484,13 @@ fn c840_l852_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 853 fn c841_l853_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c841_l853_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6794,7 +10498,13 @@ fn c841_l853_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 854 fn c842_l854_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c842_l854_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6802,7 +10512,13 @@ fn c842_l854_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 855 fn c843_l855_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c843_l855_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6810,7 +10526,13 @@ fn c843_l855_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 856 fn c844_l856_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c844_l856_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6818,7 +10540,13 @@ fn c844_l856_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 857 fn c845_l857_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c845_l857_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6826,7 +10554,13 @@ fn c845_l857_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 858 fn c846_l858_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c846_l858_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6834,7 +10568,13 @@ fn c846_l858_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 859 fn c847_l859_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c847_l859_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6842,7 +10582,13 @@ fn c847_l859_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 860 fn c848_l860_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c848_l860_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6850,7 +10596,13 @@ fn c848_l860_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 861 fn c849_l861_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c849_l861_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6858,7 +10610,13 @@ fn c849_l861_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 862 fn c850_l862_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c850_l862_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6866,7 +10624,13 @@ fn c850_l862_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 863 fn c851_l863_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c851_l863_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6874,7 +10638,13 @@ fn c851_l863_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 864 fn c852_l864_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c852_l864_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6882,7 +10652,13 @@ fn c852_l864_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 865 fn c853_l865_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c853_l865_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6890,7 +10666,13 @@ fn c853_l865_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 866 fn c854_l866_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c854_l866_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6898,7 +10680,13 @@ fn c854_l866_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 867 fn c855_l867_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c855_l867_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6906,7 +10694,13 @@ fn c855_l867_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 868 fn c856_l868_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c856_l868_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6914,7 +10708,13 @@ fn c856_l868_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 869 fn c857_l869_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c857_l869_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6922,7 +10722,13 @@ fn c857_l869_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 870 fn c858_l870_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c858_l870_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6930,7 +10736,13 @@ fn c858_l870_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 871 fn c859_l871_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c859_l871_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6938,7 +10750,13 @@ fn c859_l871_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 872 fn c860_l872_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c860_l872_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6946,7 +10764,13 @@ fn c860_l872_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 873 fn c861_l873_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c861_l873_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6954,7 +10778,13 @@ fn c861_l873_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 874 fn c862_l874_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c862_l874_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6962,7 +10792,13 @@ fn c862_l874_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 875 fn c863_l875_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c863_l875_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6970,7 +10806,13 @@ fn c863_l875_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 876 fn c864_l876_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c864_l876_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6978,7 +10820,13 @@ fn c864_l876_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 877 fn c865_l877_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c865_l877_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6986,7 +10834,13 @@ fn c865_l877_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 878 fn c866_l878_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c866_l878_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6994,7 +10848,13 @@ fn c866_l878_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 879 fn c867_l879_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c867_l879_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7002,7 +10862,13 @@ fn c867_l879_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 880 fn c868_l880_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c868_l880_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7010,7 +10876,13 @@ fn c868_l880_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 881 fn c869_l881_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c869_l881_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7018,7 +10890,13 @@ fn c869_l881_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 882 fn c870_l882_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c870_l882_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7026,7 +10904,13 @@ fn c870_l882_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 883 fn c871_l883_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c871_l883_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7034,7 +10918,13 @@ fn c871_l883_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 884 fn c872_l884_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c872_l884_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7042,7 +10932,13 @@ fn c872_l884_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 885 fn c873_l885_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c873_l885_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7050,7 +10946,13 @@ fn c873_l885_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 886 fn c874_l886_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c874_l886_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7058,7 +10960,13 @@ fn c874_l886_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 887 fn c875_l887_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c875_l887_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7066,7 +10974,13 @@ fn c875_l887_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 888 fn c876_l888_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c876_l888_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7074,7 +10988,13 @@ fn c876_l888_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 889 fn c877_l889_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c877_l889_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7082,7 +11002,13 @@ fn c877_l889_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 890 fn c878_l890_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c878_l890_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7090,7 +11016,13 @@ fn c878_l890_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 891 fn c879_l891_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c879_l891_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7098,7 +11030,13 @@ fn c879_l891_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 892 fn c880_l892_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c880_l892_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7106,7 +11044,13 @@ fn c880_l892_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 893 fn c881_l893_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c881_l893_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7114,7 +11058,13 @@ fn c881_l893_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 894 fn c882_l894_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c882_l894_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7122,7 +11072,13 @@ fn c882_l894_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 895 fn c883_l895_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c883_l895_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7130,7 +11086,13 @@ fn c883_l895_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 896 fn c884_l896_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c884_l896_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7138,7 +11100,13 @@ fn c884_l896_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 897 fn c885_l897_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c885_l897_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7146,7 +11114,13 @@ fn c885_l897_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 898 fn c886_l898_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c886_l898_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7154,7 +11128,13 @@ fn c886_l898_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 899 fn c887_l899_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c887_l899_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7162,7 +11142,13 @@ fn c887_l899_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 900 fn c888_l900_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c888_l900_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7170,7 +11156,13 @@ fn c888_l900_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 901 fn c889_l901_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c889_l901_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7178,7 +11170,13 @@ fn c889_l901_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 902 fn c890_l902_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c890_l902_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7186,7 +11184,13 @@ fn c890_l902_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 903 fn c891_l903_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c891_l903_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7194,7 +11198,13 @@ fn c891_l903_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 904 fn c892_l904_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c892_l904_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7202,7 +11212,13 @@ fn c892_l904_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 905 fn c893_l905_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c893_l905_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7210,7 +11226,13 @@ fn c893_l905_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 906 fn c894_l906_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c894_l906_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7218,7 +11240,13 @@ fn c894_l906_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 907 fn c895_l907_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c895_l907_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7226,7 +11254,13 @@ fn c895_l907_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 908 fn c896_l908_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c896_l908_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7234,7 +11268,13 @@ fn c896_l908_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 909 fn c897_l909_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c897_l909_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7242,7 +11282,13 @@ fn c897_l909_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 910 fn c898_l910_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c898_l910_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7250,7 +11296,13 @@ fn c898_l910_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 911 fn c899_l911_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c899_l911_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7258,7 +11310,13 @@ fn c899_l911_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 912 fn c900_l912_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c900_l912_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7266,7 +11324,13 @@ fn c900_l912_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 913 fn c901_l913_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c901_l913_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7274,7 +11338,13 @@ fn c901_l913_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 914 fn c902_l914_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c902_l914_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7282,7 +11352,13 @@ fn c902_l914_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 915 fn c903_l915_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c903_l915_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7290,7 +11366,13 @@ fn c903_l915_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 916 fn c904_l916_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c904_l916_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7298,7 +11380,13 @@ fn c904_l916_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 917 fn c905_l917_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c905_l917_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7306,7 +11394,13 @@ fn c905_l917_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 918 fn c906_l918_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c906_l918_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7314,7 +11408,13 @@ fn c906_l918_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 919 fn c907_l919_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c907_l919_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7322,7 +11422,13 @@ fn c907_l919_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 920 fn c908_l920_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c908_l920_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7330,7 +11436,13 @@ fn c908_l920_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 921 fn c909_l921_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c909_l921_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7338,7 +11450,13 @@ fn c909_l921_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 922 fn c910_l922_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c910_l922_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7346,7 +11464,13 @@ fn c910_l922_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 923 fn c911_l923_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c911_l923_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7354,7 +11478,13 @@ fn c911_l923_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 924 fn c912_l924_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c912_l924_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7362,7 +11492,13 @@ fn c912_l924_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 925 fn c913_l925_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c913_l925_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7370,7 +11506,13 @@ fn c913_l925_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 926 fn c914_l926_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c914_l926_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7378,7 +11520,13 @@ fn c914_l926_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 927 fn c915_l927_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c915_l927_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7386,7 +11534,13 @@ fn c915_l927_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 928 fn c916_l928_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c916_l928_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7394,7 +11548,13 @@ fn c916_l928_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 929 fn c917_l929_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c917_l929_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7402,7 +11562,13 @@ fn c917_l929_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 930 fn c918_l930_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c918_l930_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7410,7 +11576,13 @@ fn c918_l930_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 931 fn c919_l931_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c919_l931_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7418,7 +11590,13 @@ fn c919_l931_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 932 fn c920_l932_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c920_l932_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7458,7 +11636,13 @@ fn c924_l936_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 937 fn c925_l937_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c925_l937_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7466,7 +11650,13 @@ fn c925_l937_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 938 fn c926_l938_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c926_l938_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7474,7 +11664,13 @@ fn c926_l938_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 939 fn c927_l939_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c927_l939_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7482,7 +11678,13 @@ fn c927_l939_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 940 fn c928_l940_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c928_l940_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7490,7 +11692,13 @@ fn c928_l940_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 941 fn c929_l941_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c929_l941_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7498,7 +11706,13 @@ fn c929_l941_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 942 fn c930_l942_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c930_l942_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7506,7 +11720,13 @@ fn c930_l942_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 943 fn c931_l943_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c931_l943_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7514,7 +11734,13 @@ fn c931_l943_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 944 fn c932_l944_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c932_l944_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7618,7 +11844,13 @@ fn c944_l956_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 957 fn c945_l957_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c945_l957_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7626,7 +11858,13 @@ fn c945_l957_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 958 fn c946_l958_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c946_l958_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7634,7 +11872,13 @@ fn c946_l958_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 959 fn c947_l959_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c947_l959_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7642,7 +11886,13 @@ fn c947_l959_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 960 fn c948_l960_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c948_l960_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7650,7 +11900,10 @@ fn c948_l960_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 961 fn c949_l961_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c949_l961_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7682,7 +11935,13 @@ fn c952_l964_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 965 fn c953_l965_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c953_l965_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7690,7 +11949,13 @@ fn c953_l965_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 966 fn c954_l966_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c954_l966_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7698,7 +11963,13 @@ fn c954_l966_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 967 fn c955_l967_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c955_l967_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7706,7 +11977,13 @@ fn c955_l967_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 968 fn c956_l968_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c956_l968_action_invoke"); - let result = instance.call("lt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7714,7 +11991,10 @@ fn c956_l968_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 969 fn c957_l969_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c957_l969_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7722,7 +12002,10 @@ fn c957_l969_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 970 fn c958_l970_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c958_l970_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7730,7 +12013,10 @@ fn c958_l970_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 971 fn c959_l971_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c959_l971_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7738,7 +12024,10 @@ fn c959_l971_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 972 fn c960_l972_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c960_l972_action_invoke"); - let result = instance.call("lt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7778,7 +12067,13 @@ fn c964_l976_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 977 fn c965_l977_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c965_l977_action_invoke"); - let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7786,7 +12081,13 @@ fn c965_l977_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 978 fn c966_l978_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c966_l978_action_invoke"); - let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7794,7 +12095,13 @@ fn c966_l978_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 979 fn c967_l979_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c967_l979_action_invoke"); - let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7802,7 +12109,13 @@ fn c967_l979_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 980 fn c968_l980_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c968_l980_action_invoke"); - let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7810,7 +12123,13 @@ fn c968_l980_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 981 fn c969_l981_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c969_l981_action_invoke"); - let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7818,7 +12137,13 @@ fn c969_l981_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 982 fn c970_l982_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c970_l982_action_invoke"); - let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7826,7 +12151,13 @@ fn c970_l982_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 983 fn c971_l983_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c971_l983_action_invoke"); - let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7834,7 +12165,13 @@ fn c971_l983_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 984 fn c972_l984_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c972_l984_action_invoke"); - let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7938,7 +12275,13 @@ fn c984_l996_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 997 fn c985_l997_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c985_l997_action_invoke"); - let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7946,7 +12289,13 @@ fn c985_l997_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 998 fn c986_l998_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c986_l998_action_invoke"); - let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7954,7 +12303,13 @@ fn c986_l998_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 999 fn c987_l999_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c987_l999_action_invoke"); - let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7962,7 +12317,13 @@ fn c987_l999_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1000 fn c988_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c988_l1000_action_invoke"); - let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7970,7 +12331,10 @@ fn c988_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1001 fn c989_l1001_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c989_l1001_action_invoke"); - let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8002,7 +12366,13 @@ fn c992_l1004_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1005 fn c993_l1005_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c993_l1005_action_invoke"); - let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8010,7 +12380,13 @@ fn c993_l1005_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1006 fn c994_l1006_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c994_l1006_action_invoke"); - let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8018,7 +12394,13 @@ fn c994_l1006_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1007 fn c995_l1007_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c995_l1007_action_invoke"); - let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8026,7 +12408,13 @@ fn c995_l1007_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1008 fn c996_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c996_l1008_action_invoke"); - let result = instance.call("lt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8034,7 +12422,10 @@ fn c996_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1009 fn c997_l1009_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c997_l1009_action_invoke"); - let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8042,7 +12433,10 @@ fn c997_l1009_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1010 fn c998_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c998_l1010_action_invoke"); - let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8050,7 +12444,10 @@ fn c998_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1011 fn c999_l1011_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c999_l1011_action_invoke"); - let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8058,7 +12455,10 @@ fn c999_l1011_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1012 fn c1000_l1012_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1000_l1012_action_invoke"); - let result = instance.call("lt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8098,7 +12498,13 @@ fn c1004_l1016_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1017 fn c1005_l1017_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1005_l1017_action_invoke"); - let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8106,7 +12512,13 @@ fn c1005_l1017_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1018 fn c1006_l1018_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1006_l1018_action_invoke"); - let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8114,7 +12526,13 @@ fn c1006_l1018_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1019 fn c1007_l1019_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1007_l1019_action_invoke"); - let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8122,7 +12540,13 @@ fn c1007_l1019_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1020 fn c1008_l1020_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1008_l1020_action_invoke"); - let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8130,7 +12554,13 @@ fn c1008_l1020_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1021 fn c1009_l1021_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1009_l1021_action_invoke"); - let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8138,7 +12568,13 @@ fn c1009_l1021_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1022 fn c1010_l1022_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1010_l1022_action_invoke"); - let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8146,7 +12582,13 @@ fn c1010_l1022_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1023 fn c1011_l1023_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1011_l1023_action_invoke"); - let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8154,7 +12596,13 @@ fn c1011_l1023_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1024 fn c1012_l1024_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1012_l1024_action_invoke"); - let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8226,7 +12674,10 @@ fn c1020_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1033 fn c1021_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1021_l1033_action_invoke"); - let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "lt", + &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8234,7 +12685,10 @@ fn c1021_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1034 fn c1022_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1022_l1034_action_invoke"); - let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "lt", + &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8242,7 +12696,10 @@ fn c1022_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1035 fn c1023_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1023_l1035_action_invoke"); - let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "lt", + &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8250,7 +12707,10 @@ fn c1023_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1036 fn c1024_l1036_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1024_l1036_action_invoke"); - let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "lt", + &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8258,7 +12718,13 @@ fn c1024_l1036_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1037 fn c1025_l1037_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1025_l1037_action_invoke"); - let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8266,7 +12732,13 @@ fn c1025_l1037_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1038 fn c1026_l1038_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1026_l1038_action_invoke"); - let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8274,7 +12746,13 @@ fn c1026_l1038_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1039 fn c1027_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1027_l1039_action_invoke"); - let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8282,7 +12760,13 @@ fn c1027_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1040 fn c1028_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1028_l1040_action_invoke"); - let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8290,7 +12774,10 @@ fn c1028_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1041 fn c1029_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1029_l1041_action_invoke"); - let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8298,7 +12785,10 @@ fn c1029_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1042 fn c1030_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1030_l1042_action_invoke"); - let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "lt", + &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8306,7 +12796,10 @@ fn c1030_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1043 fn c1031_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1031_l1043_action_invoke"); - let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8314,7 +12807,10 @@ fn c1031_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1044 fn c1032_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1032_l1044_action_invoke"); - let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "lt", + &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8322,7 +12818,13 @@ fn c1032_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1045 fn c1033_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1033_l1045_action_invoke"); - let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8330,7 +12832,13 @@ fn c1033_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1046 fn c1034_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1034_l1046_action_invoke"); - let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8338,7 +12846,13 @@ fn c1034_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1047 fn c1035_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1035_l1047_action_invoke"); - let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8346,7 +12860,13 @@ fn c1035_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1048 fn c1036_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1036_l1048_action_invoke"); - let result = instance.call("lt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8354,7 +12874,13 @@ fn c1036_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1049 fn c1037_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1037_l1049_action_invoke"); - let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8362,7 +12888,13 @@ fn c1037_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1050 fn c1038_l1050_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1038_l1050_action_invoke"); - let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8370,7 +12902,13 @@ fn c1038_l1050_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1051 fn c1039_l1051_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1039_l1051_action_invoke"); - let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8378,7 +12916,13 @@ fn c1039_l1051_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1052 fn c1040_l1052_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1040_l1052_action_invoke"); - let result = instance.call("lt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8386,7 +12930,13 @@ fn c1040_l1052_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1053 fn c1041_l1053_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1041_l1053_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8394,7 +12944,13 @@ fn c1041_l1053_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1054 fn c1042_l1054_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1042_l1054_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8402,7 +12958,13 @@ fn c1042_l1054_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1055 fn c1043_l1055_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1043_l1055_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8410,7 +12972,13 @@ fn c1043_l1055_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1056 fn c1044_l1056_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1044_l1056_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8418,7 +12986,13 @@ fn c1044_l1056_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1057 fn c1045_l1057_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1045_l1057_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8426,7 +13000,13 @@ fn c1045_l1057_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1058 fn c1046_l1058_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1046_l1058_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8434,7 +13014,13 @@ fn c1046_l1058_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1059 fn c1047_l1059_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1047_l1059_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8442,7 +13028,13 @@ fn c1047_l1059_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1060 fn c1048_l1060_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1048_l1060_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8450,7 +13042,13 @@ fn c1048_l1060_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1061 fn c1049_l1061_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1049_l1061_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8458,7 +13056,13 @@ fn c1049_l1061_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1062 fn c1050_l1062_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1050_l1062_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8466,7 +13070,13 @@ fn c1050_l1062_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1063 fn c1051_l1063_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1051_l1063_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8474,7 +13084,13 @@ fn c1051_l1063_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1064 fn c1052_l1064_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1052_l1064_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8482,7 +13098,13 @@ fn c1052_l1064_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1065 fn c1053_l1065_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1053_l1065_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8490,7 +13112,13 @@ fn c1053_l1065_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1066 fn c1054_l1066_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1054_l1066_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8498,7 +13126,13 @@ fn c1054_l1066_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1067 fn c1055_l1067_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1055_l1067_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8506,7 +13140,13 @@ fn c1055_l1067_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1068 fn c1056_l1068_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1056_l1068_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8514,7 +13154,13 @@ fn c1056_l1068_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1069 fn c1057_l1069_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1057_l1069_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8522,7 +13168,13 @@ fn c1057_l1069_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1070 fn c1058_l1070_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1058_l1070_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8530,7 +13182,13 @@ fn c1058_l1070_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1071 fn c1059_l1071_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1059_l1071_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8538,7 +13196,13 @@ fn c1059_l1071_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1072 fn c1060_l1072_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1060_l1072_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8546,7 +13210,13 @@ fn c1060_l1072_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1073 fn c1061_l1073_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1061_l1073_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8554,7 +13224,13 @@ fn c1061_l1073_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1074 fn c1062_l1074_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1062_l1074_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8562,7 +13238,13 @@ fn c1062_l1074_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1075 fn c1063_l1075_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1063_l1075_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8570,7 +13252,13 @@ fn c1063_l1075_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1076 fn c1064_l1076_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1064_l1076_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8578,7 +13266,13 @@ fn c1064_l1076_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1077 fn c1065_l1077_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1065_l1077_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8586,7 +13280,13 @@ fn c1065_l1077_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1078 fn c1066_l1078_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1066_l1078_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8594,7 +13294,13 @@ fn c1066_l1078_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1079 fn c1067_l1079_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1067_l1079_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8602,7 +13308,13 @@ fn c1067_l1079_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1080 fn c1068_l1080_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1068_l1080_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8610,7 +13322,13 @@ fn c1068_l1080_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1081 fn c1069_l1081_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1069_l1081_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8618,7 +13336,13 @@ fn c1069_l1081_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1082 fn c1070_l1082_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1070_l1082_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8626,7 +13350,13 @@ fn c1070_l1082_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1083 fn c1071_l1083_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1071_l1083_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8634,7 +13364,13 @@ fn c1071_l1083_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1084 fn c1072_l1084_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1072_l1084_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8642,7 +13378,13 @@ fn c1072_l1084_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1085 fn c1073_l1085_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1073_l1085_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8650,7 +13392,13 @@ fn c1073_l1085_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1086 fn c1074_l1086_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1074_l1086_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8658,7 +13406,13 @@ fn c1074_l1086_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1087 fn c1075_l1087_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1075_l1087_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8666,7 +13420,13 @@ fn c1075_l1087_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1088 fn c1076_l1088_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1076_l1088_action_invoke"); - let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8674,7 +13434,13 @@ fn c1076_l1088_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1089 fn c1077_l1089_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1077_l1089_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8682,7 +13448,13 @@ fn c1077_l1089_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1090 fn c1078_l1090_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1078_l1090_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8690,7 +13462,13 @@ fn c1078_l1090_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1091 fn c1079_l1091_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1079_l1091_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8698,7 +13476,13 @@ fn c1079_l1091_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1092 fn c1080_l1092_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1080_l1092_action_invoke"); - let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8706,7 +13490,10 @@ fn c1080_l1092_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1093 fn c1081_l1093_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1081_l1093_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8738,7 +13525,13 @@ fn c1084_l1096_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1097 fn c1085_l1097_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1085_l1097_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8746,7 +13539,13 @@ fn c1085_l1097_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1098 fn c1086_l1098_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1086_l1098_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8754,7 +13553,13 @@ fn c1086_l1098_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1099 fn c1087_l1099_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1087_l1099_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8762,7 +13567,13 @@ fn c1087_l1099_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1100 fn c1088_l1100_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1088_l1100_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8770,7 +13581,13 @@ fn c1088_l1100_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1101 fn c1089_l1101_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1089_l1101_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8778,7 +13595,13 @@ fn c1089_l1101_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1102 fn c1090_l1102_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1090_l1102_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8786,7 +13609,13 @@ fn c1090_l1102_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1103 fn c1091_l1103_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1091_l1103_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8794,7 +13623,13 @@ fn c1091_l1103_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1104 fn c1092_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1092_l1104_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8802,7 +13637,10 @@ fn c1092_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1105 fn c1093_l1105_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1093_l1105_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8834,7 +13672,10 @@ fn c1096_l1108_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1109 fn c1097_l1109_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1097_l1109_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8866,7 +13707,10 @@ fn c1100_l1112_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1113 fn c1101_l1113_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1101_l1113_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8874,7 +13718,10 @@ fn c1101_l1113_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1114 fn c1102_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1102_l1114_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8882,7 +13729,10 @@ fn c1102_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1115 fn c1103_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1103_l1115_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8890,7 +13740,10 @@ fn c1103_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1116 fn c1104_l1116_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1104_l1116_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8898,7 +13751,13 @@ fn c1104_l1116_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1117 fn c1105_l1117_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1105_l1117_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8906,7 +13765,13 @@ fn c1105_l1117_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1118 fn c1106_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1106_l1118_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8914,7 +13779,13 @@ fn c1106_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1119 fn c1107_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1107_l1119_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8922,7 +13793,13 @@ fn c1107_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1120 fn c1108_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1108_l1120_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8930,7 +13807,10 @@ fn c1108_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1121 fn c1109_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1109_l1121_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8938,7 +13818,10 @@ fn c1109_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1122 fn c1110_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1110_l1122_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "lt", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8946,7 +13829,10 @@ fn c1110_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1123 fn c1111_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1111_l1123_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8954,7 +13840,10 @@ fn c1111_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1124 fn c1112_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1112_l1124_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "lt", + &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8962,7 +13851,13 @@ fn c1112_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1125 fn c1113_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1113_l1125_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8970,7 +13865,13 @@ fn c1113_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1126 fn c1114_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1114_l1126_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8978,7 +13879,13 @@ fn c1114_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1127 fn c1115_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1115_l1127_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8986,7 +13893,13 @@ fn c1115_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1128 fn c1116_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1116_l1128_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8994,7 +13907,13 @@ fn c1116_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1129 fn c1117_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1117_l1129_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9002,7 +13921,13 @@ fn c1117_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1130 fn c1118_l1130_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1118_l1130_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9010,7 +13935,13 @@ fn c1118_l1130_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1131 fn c1119_l1131_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1119_l1131_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9018,7 +13949,13 @@ fn c1119_l1131_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1132 fn c1120_l1132_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1120_l1132_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9026,7 +13963,13 @@ fn c1120_l1132_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1133 fn c1121_l1133_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1121_l1133_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9034,7 +13977,13 @@ fn c1121_l1133_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1134 fn c1122_l1134_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1122_l1134_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9042,7 +13991,10 @@ fn c1122_l1134_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1135 fn c1123_l1135_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1123_l1135_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9050,7 +14002,10 @@ fn c1123_l1135_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1136 fn c1124_l1136_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1124_l1136_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9058,7 +14013,13 @@ fn c1124_l1136_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1137 fn c1125_l1137_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1125_l1137_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9066,7 +14027,13 @@ fn c1125_l1137_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1138 fn c1126_l1138_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1126_l1138_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9074,7 +14041,10 @@ fn c1126_l1138_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1139 fn c1127_l1139_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1127_l1139_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9082,7 +14052,10 @@ fn c1127_l1139_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1140 fn c1128_l1140_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1128_l1140_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9090,7 +14063,13 @@ fn c1128_l1140_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1141 fn c1129_l1141_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1129_l1141_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9098,7 +14077,13 @@ fn c1129_l1141_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1142 fn c1130_l1142_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1130_l1142_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9106,7 +14091,13 @@ fn c1130_l1142_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1143 fn c1131_l1143_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1131_l1143_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9114,7 +14105,13 @@ fn c1131_l1143_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1144 fn c1132_l1144_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1132_l1144_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9122,7 +14119,13 @@ fn c1132_l1144_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1145 fn c1133_l1145_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1133_l1145_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9130,7 +14133,13 @@ fn c1133_l1145_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1146 fn c1134_l1146_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1134_l1146_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9138,7 +14147,13 @@ fn c1134_l1146_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1147 fn c1135_l1147_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1135_l1147_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9146,7 +14161,13 @@ fn c1135_l1147_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1148 fn c1136_l1148_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1136_l1148_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9154,7 +14175,13 @@ fn c1136_l1148_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1149 fn c1137_l1149_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1137_l1149_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9162,7 +14189,13 @@ fn c1137_l1149_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1150 fn c1138_l1150_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1138_l1150_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9170,7 +14203,13 @@ fn c1138_l1150_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1151 fn c1139_l1151_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1139_l1151_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9178,7 +14217,13 @@ fn c1139_l1151_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1152 fn c1140_l1152_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1140_l1152_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9186,7 +14231,13 @@ fn c1140_l1152_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1153 fn c1141_l1153_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1141_l1153_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9194,7 +14245,13 @@ fn c1141_l1153_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1154 fn c1142_l1154_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1142_l1154_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9202,7 +14259,13 @@ fn c1142_l1154_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1155 fn c1143_l1155_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1143_l1155_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9210,7 +14273,13 @@ fn c1143_l1155_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1156 fn c1144_l1156_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1144_l1156_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9218,7 +14287,13 @@ fn c1144_l1156_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1157 fn c1145_l1157_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1145_l1157_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9226,7 +14301,13 @@ fn c1145_l1157_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1158 fn c1146_l1158_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1146_l1158_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9234,7 +14315,10 @@ fn c1146_l1158_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1159 fn c1147_l1159_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1147_l1159_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9242,7 +14326,10 @@ fn c1147_l1159_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1160 fn c1148_l1160_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1148_l1160_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9250,7 +14337,13 @@ fn c1148_l1160_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1161 fn c1149_l1161_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1149_l1161_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9258,7 +14351,13 @@ fn c1149_l1161_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1162 fn c1150_l1162_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1150_l1162_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9266,7 +14365,10 @@ fn c1150_l1162_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1163 fn c1151_l1163_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1151_l1163_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9274,7 +14376,10 @@ fn c1151_l1163_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1164 fn c1152_l1164_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1152_l1164_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9282,7 +14387,13 @@ fn c1152_l1164_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1165 fn c1153_l1165_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1153_l1165_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9290,7 +14401,13 @@ fn c1153_l1165_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1166 fn c1154_l1166_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1154_l1166_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9298,7 +14415,10 @@ fn c1154_l1166_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1167 fn c1155_l1167_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1155_l1167_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9306,7 +14426,10 @@ fn c1155_l1167_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1168 fn c1156_l1168_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1156_l1168_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9314,7 +14437,13 @@ fn c1156_l1168_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1169 fn c1157_l1169_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1157_l1169_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9322,7 +14451,13 @@ fn c1157_l1169_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1170 fn c1158_l1170_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1158_l1170_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9330,7 +14465,10 @@ fn c1158_l1170_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1171 fn c1159_l1171_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1159_l1171_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9338,7 +14476,10 @@ fn c1159_l1171_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1172 fn c1160_l1172_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1160_l1172_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]); + let result = instance.call( + "lt", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9346,7 +14487,13 @@ fn c1160_l1172_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1173 fn c1161_l1173_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1161_l1173_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9354,7 +14501,13 @@ fn c1161_l1173_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1174 fn c1162_l1174_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1162_l1174_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9362,7 +14515,13 @@ fn c1162_l1174_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1175 fn c1163_l1175_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1163_l1175_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9370,7 +14529,13 @@ fn c1163_l1175_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1176 fn c1164_l1176_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1164_l1176_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9378,7 +14543,13 @@ fn c1164_l1176_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1177 fn c1165_l1177_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1165_l1177_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9386,7 +14557,13 @@ fn c1165_l1177_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1178 fn c1166_l1178_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1166_l1178_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9394,7 +14571,13 @@ fn c1166_l1178_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1179 fn c1167_l1179_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1167_l1179_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9402,7 +14585,13 @@ fn c1167_l1179_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1180 fn c1168_l1180_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1168_l1180_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9410,7 +14599,13 @@ fn c1168_l1180_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1181 fn c1169_l1181_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1169_l1181_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9418,7 +14613,13 @@ fn c1169_l1181_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1182 fn c1170_l1182_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1170_l1182_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9426,7 +14627,13 @@ fn c1170_l1182_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1183 fn c1171_l1183_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1171_l1183_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9434,7 +14641,13 @@ fn c1171_l1183_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1184 fn c1172_l1184_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1172_l1184_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9442,7 +14655,13 @@ fn c1172_l1184_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1185 fn c1173_l1185_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1173_l1185_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9450,7 +14669,13 @@ fn c1173_l1185_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1186 fn c1174_l1186_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1174_l1186_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9458,7 +14683,13 @@ fn c1174_l1186_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1187 fn c1175_l1187_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1175_l1187_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9466,7 +14697,13 @@ fn c1175_l1187_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1188 fn c1176_l1188_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1176_l1188_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9474,7 +14711,13 @@ fn c1176_l1188_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1189 fn c1177_l1189_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1177_l1189_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9482,7 +14725,13 @@ fn c1177_l1189_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1190 fn c1178_l1190_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1178_l1190_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9490,7 +14739,13 @@ fn c1178_l1190_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1191 fn c1179_l1191_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1179_l1191_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9498,7 +14753,13 @@ fn c1179_l1191_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1192 fn c1180_l1192_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1180_l1192_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9506,7 +14767,13 @@ fn c1180_l1192_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1193 fn c1181_l1193_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1181_l1193_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9514,7 +14781,13 @@ fn c1181_l1193_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1194 fn c1182_l1194_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1182_l1194_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9522,7 +14795,13 @@ fn c1182_l1194_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1195 fn c1183_l1195_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1183_l1195_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9530,7 +14809,13 @@ fn c1183_l1195_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1196 fn c1184_l1196_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1184_l1196_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9538,7 +14823,13 @@ fn c1184_l1196_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1197 fn c1185_l1197_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1185_l1197_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9546,7 +14837,13 @@ fn c1185_l1197_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1198 fn c1186_l1198_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1186_l1198_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9554,7 +14851,13 @@ fn c1186_l1198_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1199 fn c1187_l1199_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1187_l1199_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9562,7 +14865,13 @@ fn c1187_l1199_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1200 fn c1188_l1200_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1188_l1200_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9570,7 +14879,13 @@ fn c1188_l1200_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1201 fn c1189_l1201_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1189_l1201_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9578,7 +14893,13 @@ fn c1189_l1201_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1202 fn c1190_l1202_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1190_l1202_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9586,7 +14907,13 @@ fn c1190_l1202_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1203 fn c1191_l1203_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1191_l1203_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9594,7 +14921,13 @@ fn c1191_l1203_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1204 fn c1192_l1204_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1192_l1204_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9602,7 +14935,13 @@ fn c1192_l1204_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1205 fn c1193_l1205_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1193_l1205_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9610,7 +14949,13 @@ fn c1193_l1205_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1206 fn c1194_l1206_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1194_l1206_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9618,7 +14963,13 @@ fn c1194_l1206_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1207 fn c1195_l1207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1195_l1207_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9626,7 +14977,13 @@ fn c1195_l1207_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1208 fn c1196_l1208_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1196_l1208_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9634,7 +14991,13 @@ fn c1196_l1208_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1209 fn c1197_l1209_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1197_l1209_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9642,7 +15005,13 @@ fn c1197_l1209_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1210 fn c1198_l1210_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1198_l1210_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9650,7 +15019,13 @@ fn c1198_l1210_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1211 fn c1199_l1211_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1199_l1211_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9658,7 +15033,13 @@ fn c1199_l1211_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1212 fn c1200_l1212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1200_l1212_action_invoke"); - let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "lt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9698,7 +15079,13 @@ fn c1204_l1216_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1217 fn c1205_l1217_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1205_l1217_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9706,7 +15093,13 @@ fn c1205_l1217_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1218 fn c1206_l1218_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1206_l1218_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -9714,7 +15107,13 @@ fn c1206_l1218_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1219 fn c1207_l1219_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1207_l1219_action_invoke"); - let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9722,7 +15121,13 @@ fn c1207_l1219_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1220 fn c1208_l1220_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1208_l1220_action_invoke"); - let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -9730,7 +15135,13 @@ fn c1208_l1220_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1221 fn c1209_l1221_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1209_l1221_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9738,7 +15149,13 @@ fn c1209_l1221_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1222 fn c1210_l1222_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1210_l1222_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -9746,7 +15163,13 @@ fn c1210_l1222_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1223 fn c1211_l1223_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1211_l1223_action_invoke"); - let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9754,7 +15177,13 @@ fn c1211_l1223_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1224 fn c1212_l1224_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1212_l1224_action_invoke"); - let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -9858,7 +15287,13 @@ fn c1224_l1236_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1237 fn c1225_l1237_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1225_l1237_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9866,7 +15301,13 @@ fn c1225_l1237_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1238 fn c1226_l1238_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1226_l1238_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -9874,7 +15315,13 @@ fn c1226_l1238_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1239 fn c1227_l1239_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1227_l1239_action_invoke"); - let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9882,7 +15329,13 @@ fn c1227_l1239_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1240 fn c1228_l1240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1228_l1240_action_invoke"); - let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -9890,7 +15343,10 @@ fn c1228_l1240_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1241 fn c1229_l1241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1229_l1241_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9922,7 +15378,13 @@ fn c1232_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1245 fn c1233_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1233_l1245_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9930,7 +15392,13 @@ fn c1233_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1246 fn c1234_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1234_l1246_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9938,7 +15406,13 @@ fn c1234_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1247 fn c1235_l1247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1235_l1247_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9946,7 +15420,13 @@ fn c1235_l1247_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1248 fn c1236_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1236_l1248_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9954,7 +15434,10 @@ fn c1236_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1249 fn c1237_l1249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1237_l1249_action_invoke"); - let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9962,7 +15445,10 @@ fn c1237_l1249_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1250 fn c1238_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1238_l1250_action_invoke"); - let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9970,7 +15456,10 @@ fn c1238_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1251 fn c1239_l1251_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1239_l1251_action_invoke"); - let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9978,7 +15467,10 @@ fn c1239_l1251_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1252 fn c1240_l1252_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1240_l1252_action_invoke"); - let result = instance.call("le", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9986,7 +15478,13 @@ fn c1240_l1252_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1253 fn c1241_l1253_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1241_l1253_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -9994,7 +15492,13 @@ fn c1241_l1253_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1254 fn c1242_l1254_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1242_l1254_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10002,7 +15506,13 @@ fn c1242_l1254_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1255 fn c1243_l1255_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1243_l1255_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10010,7 +15520,13 @@ fn c1243_l1255_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1256 fn c1244_l1256_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1244_l1256_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10018,7 +15534,13 @@ fn c1244_l1256_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1257 fn c1245_l1257_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1245_l1257_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10026,7 +15548,13 @@ fn c1245_l1257_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1258 fn c1246_l1258_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1246_l1258_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10034,7 +15562,13 @@ fn c1246_l1258_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1259 fn c1247_l1259_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1247_l1259_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10042,7 +15576,13 @@ fn c1247_l1259_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1260 fn c1248_l1260_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1248_l1260_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10050,7 +15590,13 @@ fn c1248_l1260_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1261 fn c1249_l1261_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1249_l1261_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10058,7 +15604,13 @@ fn c1249_l1261_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1262 fn c1250_l1262_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1250_l1262_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10066,7 +15618,13 @@ fn c1250_l1262_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1263 fn c1251_l1263_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1251_l1263_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10074,7 +15632,13 @@ fn c1251_l1263_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1264 fn c1252_l1264_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1252_l1264_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10082,7 +15646,13 @@ fn c1252_l1264_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1265 fn c1253_l1265_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1253_l1265_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10090,7 +15660,13 @@ fn c1253_l1265_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1266 fn c1254_l1266_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1254_l1266_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10098,7 +15674,13 @@ fn c1254_l1266_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1267 fn c1255_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1255_l1267_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10106,7 +15688,13 @@ fn c1255_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1268 fn c1256_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1256_l1268_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10114,7 +15702,13 @@ fn c1256_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1269 fn c1257_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1257_l1269_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10122,7 +15716,13 @@ fn c1257_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1270 fn c1258_l1270_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1258_l1270_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10130,7 +15730,13 @@ fn c1258_l1270_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1271 fn c1259_l1271_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1259_l1271_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10138,7 +15744,13 @@ fn c1259_l1271_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1272 fn c1260_l1272_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1260_l1272_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10146,7 +15758,13 @@ fn c1260_l1272_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1273 fn c1261_l1273_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1261_l1273_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10154,7 +15772,13 @@ fn c1261_l1273_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1274 fn c1262_l1274_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1262_l1274_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10162,7 +15786,13 @@ fn c1262_l1274_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1275 fn c1263_l1275_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1263_l1275_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10170,7 +15800,13 @@ fn c1263_l1275_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1276 fn c1264_l1276_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1264_l1276_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10178,7 +15814,13 @@ fn c1264_l1276_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1277 fn c1265_l1277_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1265_l1277_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10186,7 +15828,13 @@ fn c1265_l1277_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1278 fn c1266_l1278_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1266_l1278_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10194,7 +15842,13 @@ fn c1266_l1278_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1279 fn c1267_l1279_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1267_l1279_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10202,7 +15856,13 @@ fn c1267_l1279_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1280 fn c1268_l1280_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1268_l1280_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10210,7 +15870,13 @@ fn c1268_l1280_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1281 fn c1269_l1281_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1269_l1281_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10218,7 +15884,13 @@ fn c1269_l1281_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1282 fn c1270_l1282_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1270_l1282_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10226,7 +15898,13 @@ fn c1270_l1282_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1283 fn c1271_l1283_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1271_l1283_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10234,7 +15912,13 @@ fn c1271_l1283_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1284 fn c1272_l1284_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1272_l1284_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10242,7 +15926,13 @@ fn c1272_l1284_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1285 fn c1273_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1273_l1285_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10250,7 +15940,13 @@ fn c1273_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1286 fn c1274_l1286_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1274_l1286_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10258,7 +15954,13 @@ fn c1274_l1286_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1287 fn c1275_l1287_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1275_l1287_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10266,7 +15968,13 @@ fn c1275_l1287_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1288 fn c1276_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1276_l1288_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10274,7 +15982,13 @@ fn c1276_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1289 fn c1277_l1289_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1277_l1289_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10282,7 +15996,13 @@ fn c1277_l1289_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1290 fn c1278_l1290_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1278_l1290_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10290,7 +16010,13 @@ fn c1278_l1290_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1291 fn c1279_l1291_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1279_l1291_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10298,7 +16024,13 @@ fn c1279_l1291_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1292 fn c1280_l1292_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1280_l1292_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10306,7 +16038,13 @@ fn c1280_l1292_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1293 fn c1281_l1293_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1281_l1293_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10314,7 +16052,13 @@ fn c1281_l1293_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1294 fn c1282_l1294_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1282_l1294_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10322,7 +16066,13 @@ fn c1282_l1294_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1295 fn c1283_l1295_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1283_l1295_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10330,7 +16080,13 @@ fn c1283_l1295_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1296 fn c1284_l1296_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1284_l1296_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10338,7 +16094,13 @@ fn c1284_l1296_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1297 fn c1285_l1297_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1285_l1297_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10346,7 +16108,13 @@ fn c1285_l1297_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1298 fn c1286_l1298_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1286_l1298_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10354,7 +16122,13 @@ fn c1286_l1298_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1299 fn c1287_l1299_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1287_l1299_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10362,7 +16136,13 @@ fn c1287_l1299_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1300 fn c1288_l1300_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1288_l1300_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10370,7 +16150,13 @@ fn c1288_l1300_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1301 fn c1289_l1301_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1289_l1301_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10378,7 +16164,13 @@ fn c1289_l1301_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1302 fn c1290_l1302_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1290_l1302_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10386,7 +16178,13 @@ fn c1290_l1302_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1303 fn c1291_l1303_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1291_l1303_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10394,7 +16192,13 @@ fn c1291_l1303_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1304 fn c1292_l1304_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1292_l1304_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10402,7 +16206,13 @@ fn c1292_l1304_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1305 fn c1293_l1305_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1293_l1305_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10410,7 +16220,13 @@ fn c1293_l1305_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1306 fn c1294_l1306_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1294_l1306_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10418,7 +16234,13 @@ fn c1294_l1306_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1307 fn c1295_l1307_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1295_l1307_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10426,7 +16248,13 @@ fn c1295_l1307_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1308 fn c1296_l1308_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1296_l1308_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10434,7 +16262,13 @@ fn c1296_l1308_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1309 fn c1297_l1309_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1297_l1309_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10442,7 +16276,13 @@ fn c1297_l1309_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1310 fn c1298_l1310_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1298_l1310_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10450,7 +16290,13 @@ fn c1298_l1310_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1311 fn c1299_l1311_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1299_l1311_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10458,7 +16304,13 @@ fn c1299_l1311_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1312 fn c1300_l1312_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1300_l1312_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10466,7 +16318,13 @@ fn c1300_l1312_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1313 fn c1301_l1313_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1301_l1313_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10474,7 +16332,13 @@ fn c1301_l1313_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1314 fn c1302_l1314_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1302_l1314_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10482,7 +16346,13 @@ fn c1302_l1314_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1315 fn c1303_l1315_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1303_l1315_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10490,7 +16360,13 @@ fn c1303_l1315_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1316 fn c1304_l1316_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1304_l1316_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10498,7 +16374,13 @@ fn c1304_l1316_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1317 fn c1305_l1317_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1305_l1317_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10506,7 +16388,13 @@ fn c1305_l1317_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1318 fn c1306_l1318_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1306_l1318_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10514,7 +16402,13 @@ fn c1306_l1318_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1319 fn c1307_l1319_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1307_l1319_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10522,7 +16416,13 @@ fn c1307_l1319_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1320 fn c1308_l1320_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1308_l1320_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10530,7 +16430,13 @@ fn c1308_l1320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1321 fn c1309_l1321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1309_l1321_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10538,7 +16444,13 @@ fn c1309_l1321_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1322 fn c1310_l1322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1310_l1322_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10546,7 +16458,13 @@ fn c1310_l1322_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1323 fn c1311_l1323_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1311_l1323_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10554,7 +16472,13 @@ fn c1311_l1323_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1324 fn c1312_l1324_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1312_l1324_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10562,7 +16486,13 @@ fn c1312_l1324_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1325 fn c1313_l1325_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1313_l1325_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10570,7 +16500,13 @@ fn c1313_l1325_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1326 fn c1314_l1326_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1314_l1326_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10578,7 +16514,13 @@ fn c1314_l1326_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1327 fn c1315_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1315_l1327_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10586,7 +16528,13 @@ fn c1315_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1328 fn c1316_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1316_l1328_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10594,7 +16542,13 @@ fn c1316_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1329 fn c1317_l1329_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1317_l1329_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10602,7 +16556,13 @@ fn c1317_l1329_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1330 fn c1318_l1330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1318_l1330_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10610,7 +16570,13 @@ fn c1318_l1330_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1331 fn c1319_l1331_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1319_l1331_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10618,7 +16584,13 @@ fn c1319_l1331_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1332 fn c1320_l1332_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1320_l1332_action_invoke"); - let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10658,7 +16630,13 @@ fn c1324_l1336_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1337 fn c1325_l1337_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1325_l1337_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10666,7 +16644,13 @@ fn c1325_l1337_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1338 fn c1326_l1338_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1326_l1338_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10674,7 +16658,13 @@ fn c1326_l1338_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1339 fn c1327_l1339_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1327_l1339_action_invoke"); - let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10682,7 +16672,13 @@ fn c1327_l1339_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1340 fn c1328_l1340_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1328_l1340_action_invoke"); - let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10690,7 +16686,13 @@ fn c1328_l1340_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1341 fn c1329_l1341_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1329_l1341_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10698,7 +16700,13 @@ fn c1329_l1341_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1342 fn c1330_l1342_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1330_l1342_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10706,7 +16714,13 @@ fn c1330_l1342_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1343 fn c1331_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1331_l1343_action_invoke"); - let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10714,7 +16728,13 @@ fn c1331_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1344 fn c1332_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1332_l1344_action_invoke"); - let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10818,7 +16838,13 @@ fn c1344_l1356_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1357 fn c1345_l1357_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1345_l1357_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10826,7 +16852,13 @@ fn c1345_l1357_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1358 fn c1346_l1358_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1346_l1358_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10834,7 +16866,13 @@ fn c1346_l1358_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1359 fn c1347_l1359_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1347_l1359_action_invoke"); - let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10842,7 +16880,13 @@ fn c1347_l1359_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1360 fn c1348_l1360_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1348_l1360_action_invoke"); - let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10850,7 +16894,10 @@ fn c1348_l1360_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1361 fn c1349_l1361_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1349_l1361_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10882,7 +16929,13 @@ fn c1352_l1364_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1365 fn c1353_l1365_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1353_l1365_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10890,7 +16943,13 @@ fn c1353_l1365_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1366 fn c1354_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1354_l1366_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10898,7 +16957,13 @@ fn c1354_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1367 fn c1355_l1367_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1355_l1367_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10906,7 +16971,13 @@ fn c1355_l1367_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1368 fn c1356_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1356_l1368_action_invoke"); - let result = instance.call("le", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10914,7 +16985,10 @@ fn c1356_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1369 fn c1357_l1369_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1357_l1369_action_invoke"); - let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10922,7 +16996,10 @@ fn c1357_l1369_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1370 fn c1358_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1358_l1370_action_invoke"); - let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10930,7 +17007,10 @@ fn c1358_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1371 fn c1359_l1371_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1359_l1371_action_invoke"); - let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10938,7 +17018,10 @@ fn c1359_l1371_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1372 fn c1360_l1372_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1360_l1372_action_invoke"); - let result = instance.call("le", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10978,7 +17061,13 @@ fn c1364_l1376_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1377 fn c1365_l1377_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1365_l1377_action_invoke"); - let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10986,7 +17075,13 @@ fn c1365_l1377_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1378 fn c1366_l1378_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1366_l1378_action_invoke"); - let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10994,7 +17089,13 @@ fn c1366_l1378_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1379 fn c1367_l1379_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1367_l1379_action_invoke"); - let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11002,7 +17103,13 @@ fn c1367_l1379_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1380 fn c1368_l1380_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1368_l1380_action_invoke"); - let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11010,7 +17117,13 @@ fn c1368_l1380_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1381 fn c1369_l1381_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1369_l1381_action_invoke"); - let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11018,7 +17131,13 @@ fn c1369_l1381_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1382 fn c1370_l1382_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1370_l1382_action_invoke"); - let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11026,7 +17145,13 @@ fn c1370_l1382_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1383 fn c1371_l1383_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1371_l1383_action_invoke"); - let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11034,7 +17159,13 @@ fn c1371_l1383_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1384 fn c1372_l1384_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1372_l1384_action_invoke"); - let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11138,7 +17269,13 @@ fn c1384_l1396_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1397 fn c1385_l1397_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1385_l1397_action_invoke"); - let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11146,7 +17283,13 @@ fn c1385_l1397_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1398 fn c1386_l1398_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1386_l1398_action_invoke"); - let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11154,7 +17297,13 @@ fn c1386_l1398_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1399 fn c1387_l1399_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1387_l1399_action_invoke"); - let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11162,7 +17311,13 @@ fn c1387_l1399_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1400 fn c1388_l1400_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1388_l1400_action_invoke"); - let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11170,7 +17325,10 @@ fn c1388_l1400_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1401 fn c1389_l1401_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1389_l1401_action_invoke"); - let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11202,7 +17360,13 @@ fn c1392_l1404_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1405 fn c1393_l1405_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1393_l1405_action_invoke"); - let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11210,7 +17374,13 @@ fn c1393_l1405_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1406 fn c1394_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1394_l1406_action_invoke"); - let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11218,7 +17388,13 @@ fn c1394_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1407 fn c1395_l1407_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1395_l1407_action_invoke"); - let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11226,7 +17402,13 @@ fn c1395_l1407_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1408 fn c1396_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1396_l1408_action_invoke"); - let result = instance.call("le", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11234,7 +17416,10 @@ fn c1396_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1409 fn c1397_l1409_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1397_l1409_action_invoke"); - let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11242,7 +17427,10 @@ fn c1397_l1409_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1410 fn c1398_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1398_l1410_action_invoke"); - let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11250,7 +17438,10 @@ fn c1398_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1411 fn c1399_l1411_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1399_l1411_action_invoke"); - let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11258,7 +17449,10 @@ fn c1399_l1411_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1412 fn c1400_l1412_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1400_l1412_action_invoke"); - let result = instance.call("le", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11298,7 +17492,13 @@ fn c1404_l1416_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1417 fn c1405_l1417_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1405_l1417_action_invoke"); - let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11306,7 +17506,13 @@ fn c1405_l1417_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1418 fn c1406_l1418_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1406_l1418_action_invoke"); - let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11314,7 +17520,13 @@ fn c1406_l1418_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1419 fn c1407_l1419_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1407_l1419_action_invoke"); - let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11322,7 +17534,13 @@ fn c1407_l1419_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1420 fn c1408_l1420_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1408_l1420_action_invoke"); - let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11330,7 +17548,13 @@ fn c1408_l1420_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1421 fn c1409_l1421_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1409_l1421_action_invoke"); - let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11338,7 +17562,13 @@ fn c1409_l1421_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1422 fn c1410_l1422_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1410_l1422_action_invoke"); - let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11346,7 +17576,13 @@ fn c1410_l1422_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1423 fn c1411_l1423_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1411_l1423_action_invoke"); - let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11354,7 +17590,13 @@ fn c1411_l1423_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1424 fn c1412_l1424_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1412_l1424_action_invoke"); - let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11426,7 +17668,10 @@ fn c1420_l1432_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1433 fn c1421_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1421_l1433_action_invoke"); - let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "le", + &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11434,7 +17679,10 @@ fn c1421_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1434 fn c1422_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1422_l1434_action_invoke"); - let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "le", + &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11442,7 +17690,10 @@ fn c1422_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1435 fn c1423_l1435_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1423_l1435_action_invoke"); - let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "le", + &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11450,7 +17701,10 @@ fn c1423_l1435_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1436 fn c1424_l1436_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1424_l1436_action_invoke"); - let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "le", + &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11458,7 +17712,13 @@ fn c1424_l1436_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1437 fn c1425_l1437_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1425_l1437_action_invoke"); - let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11466,7 +17726,13 @@ fn c1425_l1437_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1438 fn c1426_l1438_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1426_l1438_action_invoke"); - let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11474,7 +17740,13 @@ fn c1426_l1438_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1439 fn c1427_l1439_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1427_l1439_action_invoke"); - let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11482,7 +17754,13 @@ fn c1427_l1439_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1440 fn c1428_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1428_l1440_action_invoke"); - let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11490,7 +17768,10 @@ fn c1428_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1441 fn c1429_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1429_l1441_action_invoke"); - let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11498,7 +17779,10 @@ fn c1429_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1442 fn c1430_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1430_l1442_action_invoke"); - let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "le", + &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11506,7 +17790,10 @@ fn c1430_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1443 fn c1431_l1443_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1431_l1443_action_invoke"); - let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11514,7 +17801,10 @@ fn c1431_l1443_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1444 fn c1432_l1444_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1432_l1444_action_invoke"); - let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "le", + &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11522,7 +17812,13 @@ fn c1432_l1444_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1445 fn c1433_l1445_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1433_l1445_action_invoke"); - let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11530,7 +17826,13 @@ fn c1433_l1445_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1446 fn c1434_l1446_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1434_l1446_action_invoke"); - let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11538,7 +17840,13 @@ fn c1434_l1446_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1447 fn c1435_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1435_l1447_action_invoke"); - let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11546,7 +17854,13 @@ fn c1435_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1448 fn c1436_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1436_l1448_action_invoke"); - let result = instance.call("le", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11554,7 +17868,13 @@ fn c1436_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1449 fn c1437_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1437_l1449_action_invoke"); - let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11562,7 +17882,13 @@ fn c1437_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1450 fn c1438_l1450_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1438_l1450_action_invoke"); - let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11570,7 +17896,13 @@ fn c1438_l1450_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1451 fn c1439_l1451_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1439_l1451_action_invoke"); - let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11578,7 +17910,13 @@ fn c1439_l1451_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1452 fn c1440_l1452_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1440_l1452_action_invoke"); - let result = instance.call("le", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11586,7 +17924,13 @@ fn c1440_l1452_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1453 fn c1441_l1453_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1441_l1453_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11594,7 +17938,13 @@ fn c1441_l1453_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1454 fn c1442_l1454_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1442_l1454_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11602,7 +17952,13 @@ fn c1442_l1454_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1455 fn c1443_l1455_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1443_l1455_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11610,7 +17966,13 @@ fn c1443_l1455_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1456 fn c1444_l1456_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1444_l1456_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11618,7 +17980,13 @@ fn c1444_l1456_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1457 fn c1445_l1457_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1445_l1457_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11626,7 +17994,13 @@ fn c1445_l1457_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1458 fn c1446_l1458_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1446_l1458_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11634,7 +18008,13 @@ fn c1446_l1458_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1459 fn c1447_l1459_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1447_l1459_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11642,7 +18022,13 @@ fn c1447_l1459_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1460 fn c1448_l1460_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1448_l1460_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11650,7 +18036,13 @@ fn c1448_l1460_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1461 fn c1449_l1461_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1449_l1461_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11658,7 +18050,13 @@ fn c1449_l1461_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1462 fn c1450_l1462_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1450_l1462_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11666,7 +18064,13 @@ fn c1450_l1462_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1463 fn c1451_l1463_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1451_l1463_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11674,7 +18078,13 @@ fn c1451_l1463_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1464 fn c1452_l1464_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1452_l1464_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11682,7 +18092,13 @@ fn c1452_l1464_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1465 fn c1453_l1465_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1453_l1465_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11690,7 +18106,13 @@ fn c1453_l1465_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1466 fn c1454_l1466_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1454_l1466_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11698,7 +18120,13 @@ fn c1454_l1466_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1467 fn c1455_l1467_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1455_l1467_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11706,7 +18134,13 @@ fn c1455_l1467_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1468 fn c1456_l1468_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1456_l1468_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11714,7 +18148,13 @@ fn c1456_l1468_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1469 fn c1457_l1469_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1457_l1469_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11722,7 +18162,13 @@ fn c1457_l1469_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1470 fn c1458_l1470_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1458_l1470_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11730,7 +18176,13 @@ fn c1458_l1470_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1471 fn c1459_l1471_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1459_l1471_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11738,7 +18190,13 @@ fn c1459_l1471_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1472 fn c1460_l1472_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1460_l1472_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11746,7 +18204,13 @@ fn c1460_l1472_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1473 fn c1461_l1473_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1461_l1473_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11754,7 +18218,13 @@ fn c1461_l1473_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1474 fn c1462_l1474_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1462_l1474_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11762,7 +18232,13 @@ fn c1462_l1474_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1475 fn c1463_l1475_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1463_l1475_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11770,7 +18246,13 @@ fn c1463_l1475_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1476 fn c1464_l1476_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1464_l1476_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11778,7 +18260,13 @@ fn c1464_l1476_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1477 fn c1465_l1477_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1465_l1477_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11786,7 +18274,13 @@ fn c1465_l1477_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1478 fn c1466_l1478_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1466_l1478_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11794,7 +18288,13 @@ fn c1466_l1478_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1479 fn c1467_l1479_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1467_l1479_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11802,7 +18302,13 @@ fn c1467_l1479_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1480 fn c1468_l1480_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1468_l1480_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11810,7 +18316,13 @@ fn c1468_l1480_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1481 fn c1469_l1481_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1469_l1481_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11818,7 +18330,13 @@ fn c1469_l1481_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1482 fn c1470_l1482_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1470_l1482_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11826,7 +18344,13 @@ fn c1470_l1482_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1483 fn c1471_l1483_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1471_l1483_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11834,7 +18358,13 @@ fn c1471_l1483_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1484 fn c1472_l1484_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1472_l1484_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11842,7 +18372,13 @@ fn c1472_l1484_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1485 fn c1473_l1485_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1473_l1485_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11850,7 +18386,13 @@ fn c1473_l1485_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1486 fn c1474_l1486_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1474_l1486_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11858,7 +18400,13 @@ fn c1474_l1486_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1487 fn c1475_l1487_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1475_l1487_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11866,7 +18414,13 @@ fn c1475_l1487_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1488 fn c1476_l1488_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1476_l1488_action_invoke"); - let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11874,7 +18428,13 @@ fn c1476_l1488_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1489 fn c1477_l1489_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1477_l1489_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11882,7 +18442,13 @@ fn c1477_l1489_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1490 fn c1478_l1490_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1478_l1490_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11890,7 +18456,13 @@ fn c1478_l1490_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1491 fn c1479_l1491_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1479_l1491_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11898,7 +18470,13 @@ fn c1479_l1491_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1492 fn c1480_l1492_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1480_l1492_action_invoke"); - let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11906,7 +18484,10 @@ fn c1480_l1492_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1493 fn c1481_l1493_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1481_l1493_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11938,7 +18519,13 @@ fn c1484_l1496_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1497 fn c1485_l1497_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1485_l1497_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11946,7 +18533,13 @@ fn c1485_l1497_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1498 fn c1486_l1498_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1486_l1498_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11954,7 +18547,13 @@ fn c1486_l1498_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1499 fn c1487_l1499_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1487_l1499_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11962,7 +18561,13 @@ fn c1487_l1499_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1500 fn c1488_l1500_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1488_l1500_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11970,7 +18575,13 @@ fn c1488_l1500_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1501 fn c1489_l1501_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1489_l1501_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11978,7 +18589,13 @@ fn c1489_l1501_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1502 fn c1490_l1502_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1490_l1502_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11986,7 +18603,13 @@ fn c1490_l1502_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1503 fn c1491_l1503_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1491_l1503_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11994,7 +18617,13 @@ fn c1491_l1503_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1504 fn c1492_l1504_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1492_l1504_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12002,7 +18631,10 @@ fn c1492_l1504_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1505 fn c1493_l1505_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1493_l1505_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12034,7 +18666,10 @@ fn c1496_l1508_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1509 fn c1497_l1509_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1497_l1509_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12066,7 +18701,10 @@ fn c1500_l1512_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1513 fn c1501_l1513_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1501_l1513_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12074,7 +18712,10 @@ fn c1501_l1513_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1514 fn c1502_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1502_l1514_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12082,7 +18723,10 @@ fn c1502_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1515 fn c1503_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1503_l1515_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12090,7 +18734,10 @@ fn c1503_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1516 fn c1504_l1516_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1504_l1516_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12098,7 +18745,13 @@ fn c1504_l1516_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1517 fn c1505_l1517_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1505_l1517_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12106,7 +18759,13 @@ fn c1505_l1517_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1518 fn c1506_l1518_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1506_l1518_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12114,7 +18773,13 @@ fn c1506_l1518_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1519 fn c1507_l1519_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1507_l1519_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12122,7 +18787,13 @@ fn c1507_l1519_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1520 fn c1508_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1508_l1520_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12130,7 +18801,10 @@ fn c1508_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1521 fn c1509_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1509_l1521_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12138,7 +18812,10 @@ fn c1509_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1522 fn c1510_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1510_l1522_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "le", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12146,7 +18823,10 @@ fn c1510_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1523 fn c1511_l1523_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1511_l1523_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12154,7 +18834,10 @@ fn c1511_l1523_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1524 fn c1512_l1524_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1512_l1524_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "le", + &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12162,7 +18845,13 @@ fn c1512_l1524_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1525 fn c1513_l1525_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1513_l1525_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12170,7 +18859,13 @@ fn c1513_l1525_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1526 fn c1514_l1526_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1514_l1526_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12178,7 +18873,13 @@ fn c1514_l1526_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1527 fn c1515_l1527_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1515_l1527_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12186,7 +18887,13 @@ fn c1515_l1527_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1528 fn c1516_l1528_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1516_l1528_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12194,7 +18901,13 @@ fn c1516_l1528_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1529 fn c1517_l1529_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1517_l1529_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12202,7 +18915,13 @@ fn c1517_l1529_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1530 fn c1518_l1530_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1518_l1530_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12210,7 +18929,13 @@ fn c1518_l1530_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1531 fn c1519_l1531_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1519_l1531_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12218,7 +18943,13 @@ fn c1519_l1531_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1532 fn c1520_l1532_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1520_l1532_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12226,7 +18957,13 @@ fn c1520_l1532_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1533 fn c1521_l1533_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1521_l1533_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12234,7 +18971,13 @@ fn c1521_l1533_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1534 fn c1522_l1534_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1522_l1534_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12242,7 +18985,10 @@ fn c1522_l1534_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1535 fn c1523_l1535_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1523_l1535_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12250,7 +18996,10 @@ fn c1523_l1535_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1536 fn c1524_l1536_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1524_l1536_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12258,7 +19007,13 @@ fn c1524_l1536_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1537 fn c1525_l1537_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1525_l1537_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12266,7 +19021,13 @@ fn c1525_l1537_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1538 fn c1526_l1538_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1526_l1538_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12274,7 +19035,10 @@ fn c1526_l1538_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1539 fn c1527_l1539_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1527_l1539_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12282,7 +19046,10 @@ fn c1527_l1539_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1540 fn c1528_l1540_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1528_l1540_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12290,7 +19057,13 @@ fn c1528_l1540_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1541 fn c1529_l1541_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1529_l1541_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12298,7 +19071,13 @@ fn c1529_l1541_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1542 fn c1530_l1542_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1530_l1542_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12306,7 +19085,13 @@ fn c1530_l1542_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1543 fn c1531_l1543_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1531_l1543_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12314,7 +19099,13 @@ fn c1531_l1543_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1544 fn c1532_l1544_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1532_l1544_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12322,7 +19113,13 @@ fn c1532_l1544_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1545 fn c1533_l1545_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1533_l1545_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12330,7 +19127,13 @@ fn c1533_l1545_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1546 fn c1534_l1546_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1534_l1546_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12338,7 +19141,13 @@ fn c1534_l1546_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1547 fn c1535_l1547_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1535_l1547_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12346,7 +19155,13 @@ fn c1535_l1547_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1548 fn c1536_l1548_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1536_l1548_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12354,7 +19169,13 @@ fn c1536_l1548_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1549 fn c1537_l1549_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1537_l1549_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12362,7 +19183,13 @@ fn c1537_l1549_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1550 fn c1538_l1550_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1538_l1550_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12370,7 +19197,13 @@ fn c1538_l1550_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1551 fn c1539_l1551_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1539_l1551_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12378,7 +19211,13 @@ fn c1539_l1551_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1552 fn c1540_l1552_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1540_l1552_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12386,7 +19225,13 @@ fn c1540_l1552_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1553 fn c1541_l1553_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1541_l1553_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12394,7 +19239,13 @@ fn c1541_l1553_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1554 fn c1542_l1554_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1542_l1554_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12402,7 +19253,13 @@ fn c1542_l1554_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1555 fn c1543_l1555_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1543_l1555_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12410,7 +19267,13 @@ fn c1543_l1555_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1556 fn c1544_l1556_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1544_l1556_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12418,7 +19281,13 @@ fn c1544_l1556_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1557 fn c1545_l1557_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1545_l1557_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12426,7 +19295,13 @@ fn c1545_l1557_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1558 fn c1546_l1558_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1546_l1558_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12434,7 +19309,10 @@ fn c1546_l1558_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1559 fn c1547_l1559_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1547_l1559_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12442,7 +19320,10 @@ fn c1547_l1559_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1560 fn c1548_l1560_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1548_l1560_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12450,7 +19331,13 @@ fn c1548_l1560_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1561 fn c1549_l1561_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1549_l1561_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12458,7 +19345,13 @@ fn c1549_l1561_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1562 fn c1550_l1562_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1550_l1562_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12466,7 +19359,10 @@ fn c1550_l1562_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1563 fn c1551_l1563_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1551_l1563_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12474,7 +19370,10 @@ fn c1551_l1563_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1564 fn c1552_l1564_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1552_l1564_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12482,7 +19381,13 @@ fn c1552_l1564_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1565 fn c1553_l1565_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1553_l1565_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12490,7 +19395,13 @@ fn c1553_l1565_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1566 fn c1554_l1566_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1554_l1566_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12498,7 +19409,10 @@ fn c1554_l1566_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1567 fn c1555_l1567_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1555_l1567_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12506,7 +19420,10 @@ fn c1555_l1567_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1568 fn c1556_l1568_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1556_l1568_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12514,7 +19431,13 @@ fn c1556_l1568_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1569 fn c1557_l1569_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1557_l1569_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12522,7 +19445,13 @@ fn c1557_l1569_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1570 fn c1558_l1570_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1558_l1570_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12530,7 +19459,10 @@ fn c1558_l1570_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1571 fn c1559_l1571_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1559_l1571_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12538,7 +19470,10 @@ fn c1559_l1571_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1572 fn c1560_l1572_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1560_l1572_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]); + let result = instance.call( + "le", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12546,7 +19481,13 @@ fn c1560_l1572_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1573 fn c1561_l1573_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1561_l1573_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12554,7 +19495,13 @@ fn c1561_l1573_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1574 fn c1562_l1574_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1562_l1574_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12562,7 +19509,13 @@ fn c1562_l1574_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1575 fn c1563_l1575_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1563_l1575_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12570,7 +19523,13 @@ fn c1563_l1575_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1576 fn c1564_l1576_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1564_l1576_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12578,7 +19537,13 @@ fn c1564_l1576_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1577 fn c1565_l1577_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1565_l1577_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12586,7 +19551,13 @@ fn c1565_l1577_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1578 fn c1566_l1578_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1566_l1578_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12594,7 +19565,13 @@ fn c1566_l1578_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1579 fn c1567_l1579_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1567_l1579_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12602,7 +19579,13 @@ fn c1567_l1579_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1580 fn c1568_l1580_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1568_l1580_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12610,7 +19593,13 @@ fn c1568_l1580_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1581 fn c1569_l1581_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1569_l1581_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12618,7 +19607,13 @@ fn c1569_l1581_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1582 fn c1570_l1582_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1570_l1582_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12626,7 +19621,13 @@ fn c1570_l1582_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1583 fn c1571_l1583_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1571_l1583_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12634,7 +19635,13 @@ fn c1571_l1583_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1584 fn c1572_l1584_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1572_l1584_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12642,7 +19649,13 @@ fn c1572_l1584_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1585 fn c1573_l1585_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1573_l1585_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12650,7 +19663,13 @@ fn c1573_l1585_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1586 fn c1574_l1586_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1574_l1586_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12658,7 +19677,13 @@ fn c1574_l1586_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1587 fn c1575_l1587_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1575_l1587_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12666,7 +19691,13 @@ fn c1575_l1587_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1588 fn c1576_l1588_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1576_l1588_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12674,7 +19705,13 @@ fn c1576_l1588_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1589 fn c1577_l1589_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1577_l1589_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12682,7 +19719,13 @@ fn c1577_l1589_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1590 fn c1578_l1590_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1578_l1590_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12690,7 +19733,13 @@ fn c1578_l1590_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1591 fn c1579_l1591_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1579_l1591_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12698,7 +19747,13 @@ fn c1579_l1591_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1592 fn c1580_l1592_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1580_l1592_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12706,7 +19761,13 @@ fn c1580_l1592_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1593 fn c1581_l1593_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1581_l1593_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12714,7 +19775,13 @@ fn c1581_l1593_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1594 fn c1582_l1594_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1582_l1594_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12722,7 +19789,13 @@ fn c1582_l1594_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1595 fn c1583_l1595_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1583_l1595_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12730,7 +19803,13 @@ fn c1583_l1595_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1596 fn c1584_l1596_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1584_l1596_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12738,7 +19817,13 @@ fn c1584_l1596_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1597 fn c1585_l1597_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1585_l1597_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12746,7 +19831,13 @@ fn c1585_l1597_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1598 fn c1586_l1598_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1586_l1598_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12754,7 +19845,13 @@ fn c1586_l1598_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1599 fn c1587_l1599_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1587_l1599_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12762,7 +19859,13 @@ fn c1587_l1599_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1600 fn c1588_l1600_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1588_l1600_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12770,7 +19873,13 @@ fn c1588_l1600_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1601 fn c1589_l1601_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1589_l1601_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12778,7 +19887,13 @@ fn c1589_l1601_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1602 fn c1590_l1602_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1590_l1602_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12786,7 +19901,13 @@ fn c1590_l1602_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1603 fn c1591_l1603_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1591_l1603_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12794,7 +19915,13 @@ fn c1591_l1603_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1604 fn c1592_l1604_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1592_l1604_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12802,7 +19929,13 @@ fn c1592_l1604_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1605 fn c1593_l1605_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1593_l1605_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12810,7 +19943,13 @@ fn c1593_l1605_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1606 fn c1594_l1606_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1594_l1606_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12818,7 +19957,13 @@ fn c1594_l1606_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1607 fn c1595_l1607_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1595_l1607_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12826,7 +19971,13 @@ fn c1595_l1607_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1608 fn c1596_l1608_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1596_l1608_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12834,7 +19985,13 @@ fn c1596_l1608_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1609 fn c1597_l1609_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1597_l1609_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12842,7 +19999,13 @@ fn c1597_l1609_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1610 fn c1598_l1610_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1598_l1610_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12850,7 +20013,13 @@ fn c1598_l1610_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1611 fn c1599_l1611_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1599_l1611_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12858,7 +20027,13 @@ fn c1599_l1611_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1612 fn c1600_l1612_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1600_l1612_action_invoke"); - let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "le", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12898,7 +20073,13 @@ fn c1604_l1616_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1617 fn c1605_l1617_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1605_l1617_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12906,7 +20087,13 @@ fn c1605_l1617_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1618 fn c1606_l1618_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1606_l1618_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12914,7 +20101,13 @@ fn c1606_l1618_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1619 fn c1607_l1619_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1607_l1619_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12922,7 +20115,13 @@ fn c1607_l1619_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1620 fn c1608_l1620_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1608_l1620_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12930,7 +20129,13 @@ fn c1608_l1620_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1621 fn c1609_l1621_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1609_l1621_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12938,7 +20143,13 @@ fn c1609_l1621_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1622 fn c1610_l1622_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1610_l1622_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12946,7 +20157,13 @@ fn c1610_l1622_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1623 fn c1611_l1623_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1611_l1623_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12954,7 +20171,13 @@ fn c1611_l1623_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1624 fn c1612_l1624_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1612_l1624_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13058,7 +20281,13 @@ fn c1624_l1636_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1637 fn c1625_l1637_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1625_l1637_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13066,7 +20295,13 @@ fn c1625_l1637_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1638 fn c1626_l1638_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1626_l1638_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13074,7 +20309,13 @@ fn c1626_l1638_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1639 fn c1627_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1627_l1639_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13082,7 +20323,13 @@ fn c1627_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1640 fn c1628_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1628_l1640_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13090,7 +20337,10 @@ fn c1628_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1641 fn c1629_l1641_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1629_l1641_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13122,7 +20372,13 @@ fn c1632_l1644_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1645 fn c1633_l1645_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1633_l1645_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13130,7 +20386,13 @@ fn c1633_l1645_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1646 fn c1634_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1634_l1646_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13138,7 +20400,13 @@ fn c1634_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1647 fn c1635_l1647_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1635_l1647_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13146,7 +20414,13 @@ fn c1635_l1647_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1648 fn c1636_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1636_l1648_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13154,7 +20428,10 @@ fn c1636_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1649 fn c1637_l1649_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1637_l1649_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13162,7 +20439,10 @@ fn c1637_l1649_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1650 fn c1638_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1638_l1650_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13170,7 +20450,10 @@ fn c1638_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1651 fn c1639_l1651_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1639_l1651_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13178,7 +20461,10 @@ fn c1639_l1651_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1652 fn c1640_l1652_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1640_l1652_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13186,7 +20472,13 @@ fn c1640_l1652_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1653 fn c1641_l1653_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1641_l1653_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13194,7 +20486,13 @@ fn c1641_l1653_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1654 fn c1642_l1654_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1642_l1654_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13202,7 +20500,13 @@ fn c1642_l1654_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1655 fn c1643_l1655_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1643_l1655_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13210,7 +20514,13 @@ fn c1643_l1655_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1656 fn c1644_l1656_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1644_l1656_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13218,7 +20528,13 @@ fn c1644_l1656_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1657 fn c1645_l1657_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1645_l1657_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13226,7 +20542,13 @@ fn c1645_l1657_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1658 fn c1646_l1658_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1646_l1658_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13234,7 +20556,13 @@ fn c1646_l1658_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1659 fn c1647_l1659_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1647_l1659_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13242,7 +20570,13 @@ fn c1647_l1659_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1660 fn c1648_l1660_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1648_l1660_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13250,7 +20584,13 @@ fn c1648_l1660_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1661 fn c1649_l1661_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1649_l1661_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13258,7 +20598,13 @@ fn c1649_l1661_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1662 fn c1650_l1662_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1650_l1662_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13266,7 +20612,13 @@ fn c1650_l1662_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1663 fn c1651_l1663_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1651_l1663_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13274,7 +20626,13 @@ fn c1651_l1663_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1664 fn c1652_l1664_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1652_l1664_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13282,7 +20640,13 @@ fn c1652_l1664_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1665 fn c1653_l1665_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1653_l1665_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13290,7 +20654,13 @@ fn c1653_l1665_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1666 fn c1654_l1666_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1654_l1666_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13298,7 +20668,13 @@ fn c1654_l1666_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1667 fn c1655_l1667_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1655_l1667_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13306,7 +20682,13 @@ fn c1655_l1667_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1668 fn c1656_l1668_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1656_l1668_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13314,7 +20696,13 @@ fn c1656_l1668_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1669 fn c1657_l1669_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1657_l1669_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13322,7 +20710,13 @@ fn c1657_l1669_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1670 fn c1658_l1670_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1658_l1670_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13330,7 +20724,13 @@ fn c1658_l1670_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1671 fn c1659_l1671_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1659_l1671_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13338,7 +20738,13 @@ fn c1659_l1671_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1672 fn c1660_l1672_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1660_l1672_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13346,7 +20752,13 @@ fn c1660_l1672_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1673 fn c1661_l1673_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1661_l1673_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13354,7 +20766,13 @@ fn c1661_l1673_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1674 fn c1662_l1674_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1662_l1674_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13362,7 +20780,13 @@ fn c1662_l1674_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1675 fn c1663_l1675_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1663_l1675_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13370,7 +20794,13 @@ fn c1663_l1675_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1676 fn c1664_l1676_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1664_l1676_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13378,7 +20808,13 @@ fn c1664_l1676_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1677 fn c1665_l1677_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1665_l1677_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13386,7 +20822,13 @@ fn c1665_l1677_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1678 fn c1666_l1678_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1666_l1678_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13394,7 +20836,13 @@ fn c1666_l1678_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1679 fn c1667_l1679_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1667_l1679_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13402,7 +20850,13 @@ fn c1667_l1679_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1680 fn c1668_l1680_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1668_l1680_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13410,7 +20864,13 @@ fn c1668_l1680_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1681 fn c1669_l1681_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1669_l1681_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13418,7 +20878,13 @@ fn c1669_l1681_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1682 fn c1670_l1682_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1670_l1682_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13426,7 +20892,13 @@ fn c1670_l1682_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1683 fn c1671_l1683_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1671_l1683_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13434,7 +20906,13 @@ fn c1671_l1683_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1684 fn c1672_l1684_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1672_l1684_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13442,7 +20920,13 @@ fn c1672_l1684_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1685 fn c1673_l1685_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1673_l1685_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13450,7 +20934,13 @@ fn c1673_l1685_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1686 fn c1674_l1686_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1674_l1686_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13458,7 +20948,13 @@ fn c1674_l1686_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1687 fn c1675_l1687_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1675_l1687_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13466,7 +20962,13 @@ fn c1675_l1687_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1688 fn c1676_l1688_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1676_l1688_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13474,7 +20976,13 @@ fn c1676_l1688_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1689 fn c1677_l1689_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1677_l1689_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13482,7 +20990,13 @@ fn c1677_l1689_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1690 fn c1678_l1690_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1678_l1690_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13490,7 +21004,13 @@ fn c1678_l1690_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1691 fn c1679_l1691_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1679_l1691_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13498,7 +21018,13 @@ fn c1679_l1691_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1692 fn c1680_l1692_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1680_l1692_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13506,7 +21032,13 @@ fn c1680_l1692_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1693 fn c1681_l1693_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1681_l1693_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13514,7 +21046,13 @@ fn c1681_l1693_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1694 fn c1682_l1694_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1682_l1694_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13522,7 +21060,13 @@ fn c1682_l1694_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1695 fn c1683_l1695_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1683_l1695_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13530,7 +21074,13 @@ fn c1683_l1695_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1696 fn c1684_l1696_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1684_l1696_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13538,7 +21088,13 @@ fn c1684_l1696_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1697 fn c1685_l1697_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1685_l1697_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13546,7 +21102,13 @@ fn c1685_l1697_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1698 fn c1686_l1698_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1686_l1698_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13554,7 +21116,13 @@ fn c1686_l1698_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1699 fn c1687_l1699_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1687_l1699_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13562,7 +21130,13 @@ fn c1687_l1699_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1700 fn c1688_l1700_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1688_l1700_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13570,7 +21144,13 @@ fn c1688_l1700_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1701 fn c1689_l1701_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1689_l1701_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13578,7 +21158,13 @@ fn c1689_l1701_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1702 fn c1690_l1702_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1690_l1702_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13586,7 +21172,13 @@ fn c1690_l1702_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1703 fn c1691_l1703_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1691_l1703_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13594,7 +21186,13 @@ fn c1691_l1703_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1704 fn c1692_l1704_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1692_l1704_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13602,7 +21200,13 @@ fn c1692_l1704_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1705 fn c1693_l1705_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1693_l1705_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13610,7 +21214,13 @@ fn c1693_l1705_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1706 fn c1694_l1706_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1694_l1706_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13618,7 +21228,13 @@ fn c1694_l1706_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1707 fn c1695_l1707_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1695_l1707_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13626,7 +21242,13 @@ fn c1695_l1707_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1708 fn c1696_l1708_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1696_l1708_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13634,7 +21256,13 @@ fn c1696_l1708_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1709 fn c1697_l1709_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1697_l1709_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13642,7 +21270,13 @@ fn c1697_l1709_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1710 fn c1698_l1710_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1698_l1710_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13650,7 +21284,13 @@ fn c1698_l1710_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1711 fn c1699_l1711_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1699_l1711_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13658,7 +21298,13 @@ fn c1699_l1711_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1712 fn c1700_l1712_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1700_l1712_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13666,7 +21312,13 @@ fn c1700_l1712_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1713 fn c1701_l1713_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1701_l1713_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13674,7 +21326,13 @@ fn c1701_l1713_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1714 fn c1702_l1714_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1702_l1714_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13682,7 +21340,13 @@ fn c1702_l1714_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1715 fn c1703_l1715_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1703_l1715_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13690,7 +21354,13 @@ fn c1703_l1715_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1716 fn c1704_l1716_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1704_l1716_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13698,7 +21368,13 @@ fn c1704_l1716_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1717 fn c1705_l1717_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1705_l1717_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13706,7 +21382,13 @@ fn c1705_l1717_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1718 fn c1706_l1718_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1706_l1718_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13714,7 +21396,13 @@ fn c1706_l1718_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1719 fn c1707_l1719_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1707_l1719_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13722,7 +21410,13 @@ fn c1707_l1719_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1720 fn c1708_l1720_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1708_l1720_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13730,7 +21424,13 @@ fn c1708_l1720_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1721 fn c1709_l1721_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1709_l1721_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13738,7 +21438,13 @@ fn c1709_l1721_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1722 fn c1710_l1722_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1710_l1722_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13746,7 +21452,13 @@ fn c1710_l1722_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1723 fn c1711_l1723_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1711_l1723_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13754,7 +21466,13 @@ fn c1711_l1723_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1724 fn c1712_l1724_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1712_l1724_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13762,7 +21480,13 @@ fn c1712_l1724_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1725 fn c1713_l1725_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1713_l1725_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13770,7 +21494,13 @@ fn c1713_l1725_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1726 fn c1714_l1726_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1714_l1726_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13778,7 +21508,13 @@ fn c1714_l1726_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1727 fn c1715_l1727_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1715_l1727_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13786,7 +21522,13 @@ fn c1715_l1727_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1728 fn c1716_l1728_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1716_l1728_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13794,7 +21536,13 @@ fn c1716_l1728_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1729 fn c1717_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1717_l1729_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13802,7 +21550,13 @@ fn c1717_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1730 fn c1718_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1718_l1730_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13810,7 +21564,13 @@ fn c1718_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1731 fn c1719_l1731_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1719_l1731_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13818,7 +21578,13 @@ fn c1719_l1731_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1732 fn c1720_l1732_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1720_l1732_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13858,7 +21624,13 @@ fn c1724_l1736_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1737 fn c1725_l1737_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1725_l1737_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13866,7 +21638,13 @@ fn c1725_l1737_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1738 fn c1726_l1738_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1726_l1738_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13874,7 +21652,13 @@ fn c1726_l1738_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1739 fn c1727_l1739_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1727_l1739_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13882,7 +21666,13 @@ fn c1727_l1739_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1740 fn c1728_l1740_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1728_l1740_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13890,7 +21680,13 @@ fn c1728_l1740_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1741 fn c1729_l1741_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1729_l1741_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13898,7 +21694,13 @@ fn c1729_l1741_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1742 fn c1730_l1742_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1730_l1742_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13906,7 +21708,13 @@ fn c1730_l1742_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1743 fn c1731_l1743_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1731_l1743_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13914,7 +21722,13 @@ fn c1731_l1743_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1744 fn c1732_l1744_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1732_l1744_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14018,7 +21832,13 @@ fn c1744_l1756_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1757 fn c1745_l1757_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1745_l1757_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14026,7 +21846,13 @@ fn c1745_l1757_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1758 fn c1746_l1758_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1746_l1758_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14034,7 +21860,13 @@ fn c1746_l1758_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1759 fn c1747_l1759_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1747_l1759_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14042,7 +21874,13 @@ fn c1747_l1759_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1760 fn c1748_l1760_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1748_l1760_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14050,7 +21888,10 @@ fn c1748_l1760_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1761 fn c1749_l1761_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1749_l1761_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14082,7 +21923,13 @@ fn c1752_l1764_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1765 fn c1753_l1765_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1753_l1765_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14090,7 +21937,13 @@ fn c1753_l1765_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1766 fn c1754_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1754_l1766_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14098,7 +21951,13 @@ fn c1754_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1767 fn c1755_l1767_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1755_l1767_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14106,7 +21965,13 @@ fn c1755_l1767_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1768 fn c1756_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1756_l1768_action_invoke"); - let result = instance.call("gt", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14114,7 +21979,10 @@ fn c1756_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1769 fn c1757_l1769_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1757_l1769_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14122,7 +21990,10 @@ fn c1757_l1769_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1770 fn c1758_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1758_l1770_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14130,7 +22001,10 @@ fn c1758_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1771 fn c1759_l1771_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1759_l1771_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14138,7 +22012,10 @@ fn c1759_l1771_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1772 fn c1760_l1772_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1760_l1772_action_invoke"); - let result = instance.call("gt", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14178,7 +22055,13 @@ fn c1764_l1776_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1777 fn c1765_l1777_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1765_l1777_action_invoke"); - let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14186,7 +22069,13 @@ fn c1765_l1777_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1778 fn c1766_l1778_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1766_l1778_action_invoke"); - let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14194,7 +22083,13 @@ fn c1766_l1778_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1779 fn c1767_l1779_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1767_l1779_action_invoke"); - let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14202,7 +22097,13 @@ fn c1767_l1779_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1780 fn c1768_l1780_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1768_l1780_action_invoke"); - let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14210,7 +22111,13 @@ fn c1768_l1780_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1781 fn c1769_l1781_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1769_l1781_action_invoke"); - let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14218,7 +22125,13 @@ fn c1769_l1781_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1782 fn c1770_l1782_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1770_l1782_action_invoke"); - let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14226,7 +22139,13 @@ fn c1770_l1782_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1783 fn c1771_l1783_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1771_l1783_action_invoke"); - let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14234,7 +22153,13 @@ fn c1771_l1783_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1784 fn c1772_l1784_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1772_l1784_action_invoke"); - let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14338,7 +22263,13 @@ fn c1784_l1796_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1797 fn c1785_l1797_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1785_l1797_action_invoke"); - let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14346,7 +22277,13 @@ fn c1785_l1797_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1798 fn c1786_l1798_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1786_l1798_action_invoke"); - let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14354,7 +22291,13 @@ fn c1786_l1798_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1799 fn c1787_l1799_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1787_l1799_action_invoke"); - let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14362,7 +22305,13 @@ fn c1787_l1799_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1800 fn c1788_l1800_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1788_l1800_action_invoke"); - let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14370,7 +22319,10 @@ fn c1788_l1800_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1801 fn c1789_l1801_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1789_l1801_action_invoke"); - let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14402,7 +22354,13 @@ fn c1792_l1804_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1805 fn c1793_l1805_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1793_l1805_action_invoke"); - let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14410,7 +22368,13 @@ fn c1793_l1805_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1806 fn c1794_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1794_l1806_action_invoke"); - let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14418,7 +22382,13 @@ fn c1794_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1807 fn c1795_l1807_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1795_l1807_action_invoke"); - let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14426,7 +22396,13 @@ fn c1795_l1807_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1808 fn c1796_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1796_l1808_action_invoke"); - let result = instance.call("gt", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14434,7 +22410,10 @@ fn c1796_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1809 fn c1797_l1809_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1797_l1809_action_invoke"); - let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14442,7 +22421,10 @@ fn c1797_l1809_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1810 fn c1798_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1798_l1810_action_invoke"); - let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14450,7 +22432,10 @@ fn c1798_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1811 fn c1799_l1811_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1799_l1811_action_invoke"); - let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14458,7 +22443,10 @@ fn c1799_l1811_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1812 fn c1800_l1812_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1800_l1812_action_invoke"); - let result = instance.call("gt", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14498,7 +22486,13 @@ fn c1804_l1816_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1817 fn c1805_l1817_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1805_l1817_action_invoke"); - let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14506,7 +22500,13 @@ fn c1805_l1817_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1818 fn c1806_l1818_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1806_l1818_action_invoke"); - let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14514,7 +22514,13 @@ fn c1806_l1818_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1819 fn c1807_l1819_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1807_l1819_action_invoke"); - let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14522,7 +22528,13 @@ fn c1807_l1819_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1820 fn c1808_l1820_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1808_l1820_action_invoke"); - let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14530,7 +22542,13 @@ fn c1808_l1820_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1821 fn c1809_l1821_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1809_l1821_action_invoke"); - let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14538,7 +22556,13 @@ fn c1809_l1821_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1822 fn c1810_l1822_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1810_l1822_action_invoke"); - let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14546,7 +22570,13 @@ fn c1810_l1822_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1823 fn c1811_l1823_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1811_l1823_action_invoke"); - let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14554,7 +22584,13 @@ fn c1811_l1823_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1824 fn c1812_l1824_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1812_l1824_action_invoke"); - let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14626,7 +22662,10 @@ fn c1820_l1832_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1833 fn c1821_l1833_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1821_l1833_action_invoke"); - let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "gt", + &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14634,7 +22673,10 @@ fn c1821_l1833_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1834 fn c1822_l1834_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1822_l1834_action_invoke"); - let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "gt", + &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14642,7 +22684,10 @@ fn c1822_l1834_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1835 fn c1823_l1835_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1823_l1835_action_invoke"); - let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "gt", + &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14650,7 +22695,10 @@ fn c1823_l1835_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1836 fn c1824_l1836_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1824_l1836_action_invoke"); - let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "gt", + &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14658,7 +22706,13 @@ fn c1824_l1836_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1837 fn c1825_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1825_l1837_action_invoke"); - let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14666,7 +22720,13 @@ fn c1825_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1838 fn c1826_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1826_l1838_action_invoke"); - let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14674,7 +22734,13 @@ fn c1826_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1839 fn c1827_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1827_l1839_action_invoke"); - let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14682,7 +22748,13 @@ fn c1827_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1840 fn c1828_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1828_l1840_action_invoke"); - let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14690,7 +22762,10 @@ fn c1828_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1841 fn c1829_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1829_l1841_action_invoke"); - let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14698,7 +22773,10 @@ fn c1829_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1842 fn c1830_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1830_l1842_action_invoke"); - let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "gt", + &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14706,7 +22784,10 @@ fn c1830_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1843 fn c1831_l1843_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1831_l1843_action_invoke"); - let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14714,7 +22795,10 @@ fn c1831_l1843_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1844 fn c1832_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1832_l1844_action_invoke"); - let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "gt", + &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14722,7 +22806,13 @@ fn c1832_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1845 fn c1833_l1845_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1833_l1845_action_invoke"); - let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14730,7 +22820,13 @@ fn c1833_l1845_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1846 fn c1834_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1834_l1846_action_invoke"); - let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14738,7 +22834,13 @@ fn c1834_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1847 fn c1835_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1835_l1847_action_invoke"); - let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14746,7 +22848,13 @@ fn c1835_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1848 fn c1836_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1836_l1848_action_invoke"); - let result = instance.call("gt", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14754,7 +22862,13 @@ fn c1836_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1849 fn c1837_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1837_l1849_action_invoke"); - let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14762,7 +22876,13 @@ fn c1837_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1850 fn c1838_l1850_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1838_l1850_action_invoke"); - let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14770,7 +22890,13 @@ fn c1838_l1850_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1851 fn c1839_l1851_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1839_l1851_action_invoke"); - let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14778,7 +22904,13 @@ fn c1839_l1851_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1852 fn c1840_l1852_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1840_l1852_action_invoke"); - let result = instance.call("gt", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14786,7 +22918,13 @@ fn c1840_l1852_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1853 fn c1841_l1853_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1841_l1853_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14794,7 +22932,13 @@ fn c1841_l1853_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1854 fn c1842_l1854_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1842_l1854_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14802,7 +22946,13 @@ fn c1842_l1854_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1855 fn c1843_l1855_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1843_l1855_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14810,7 +22960,13 @@ fn c1843_l1855_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1856 fn c1844_l1856_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1844_l1856_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14818,7 +22974,13 @@ fn c1844_l1856_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1857 fn c1845_l1857_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1845_l1857_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14826,7 +22988,13 @@ fn c1845_l1857_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1858 fn c1846_l1858_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1846_l1858_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14834,7 +23002,13 @@ fn c1846_l1858_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1859 fn c1847_l1859_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1847_l1859_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14842,7 +23016,13 @@ fn c1847_l1859_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1860 fn c1848_l1860_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1848_l1860_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14850,7 +23030,13 @@ fn c1848_l1860_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1861 fn c1849_l1861_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1849_l1861_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14858,7 +23044,13 @@ fn c1849_l1861_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1862 fn c1850_l1862_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1850_l1862_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14866,7 +23058,13 @@ fn c1850_l1862_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1863 fn c1851_l1863_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1851_l1863_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14874,7 +23072,13 @@ fn c1851_l1863_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1864 fn c1852_l1864_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1852_l1864_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14882,7 +23086,13 @@ fn c1852_l1864_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1865 fn c1853_l1865_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1853_l1865_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14890,7 +23100,13 @@ fn c1853_l1865_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1866 fn c1854_l1866_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1854_l1866_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14898,7 +23114,13 @@ fn c1854_l1866_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1867 fn c1855_l1867_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1855_l1867_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14906,7 +23128,13 @@ fn c1855_l1867_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1868 fn c1856_l1868_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1856_l1868_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14914,7 +23142,13 @@ fn c1856_l1868_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1869 fn c1857_l1869_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1857_l1869_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14922,7 +23156,13 @@ fn c1857_l1869_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1870 fn c1858_l1870_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1858_l1870_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14930,7 +23170,13 @@ fn c1858_l1870_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1871 fn c1859_l1871_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1859_l1871_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14938,7 +23184,13 @@ fn c1859_l1871_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1872 fn c1860_l1872_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1860_l1872_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14946,7 +23198,13 @@ fn c1860_l1872_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1873 fn c1861_l1873_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1861_l1873_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14954,7 +23212,13 @@ fn c1861_l1873_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1874 fn c1862_l1874_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1862_l1874_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14962,7 +23226,13 @@ fn c1862_l1874_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1875 fn c1863_l1875_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1863_l1875_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14970,7 +23240,13 @@ fn c1863_l1875_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1876 fn c1864_l1876_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1864_l1876_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14978,7 +23254,13 @@ fn c1864_l1876_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1877 fn c1865_l1877_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1865_l1877_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14986,7 +23268,13 @@ fn c1865_l1877_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1878 fn c1866_l1878_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1866_l1878_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14994,7 +23282,13 @@ fn c1866_l1878_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1879 fn c1867_l1879_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1867_l1879_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15002,7 +23296,13 @@ fn c1867_l1879_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1880 fn c1868_l1880_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1868_l1880_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15010,7 +23310,13 @@ fn c1868_l1880_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1881 fn c1869_l1881_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1869_l1881_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15018,7 +23324,13 @@ fn c1869_l1881_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1882 fn c1870_l1882_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1870_l1882_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15026,7 +23338,13 @@ fn c1870_l1882_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1883 fn c1871_l1883_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1871_l1883_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15034,7 +23352,13 @@ fn c1871_l1883_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1884 fn c1872_l1884_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1872_l1884_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15042,7 +23366,13 @@ fn c1872_l1884_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1885 fn c1873_l1885_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1873_l1885_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15050,7 +23380,13 @@ fn c1873_l1885_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1886 fn c1874_l1886_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1874_l1886_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15058,7 +23394,13 @@ fn c1874_l1886_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1887 fn c1875_l1887_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1875_l1887_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15066,7 +23408,13 @@ fn c1875_l1887_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1888 fn c1876_l1888_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1876_l1888_action_invoke"); - let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15074,7 +23422,13 @@ fn c1876_l1888_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1889 fn c1877_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1877_l1889_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15082,7 +23436,13 @@ fn c1877_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1890 fn c1878_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1878_l1890_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15090,7 +23450,13 @@ fn c1878_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1891 fn c1879_l1891_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1879_l1891_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15098,7 +23464,13 @@ fn c1879_l1891_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1892 fn c1880_l1892_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1880_l1892_action_invoke"); - let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15106,7 +23478,10 @@ fn c1880_l1892_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1893 fn c1881_l1893_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1881_l1893_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15138,7 +23513,13 @@ fn c1884_l1896_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1897 fn c1885_l1897_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1885_l1897_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15146,7 +23527,13 @@ fn c1885_l1897_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1898 fn c1886_l1898_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1886_l1898_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15154,7 +23541,13 @@ fn c1886_l1898_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1899 fn c1887_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1887_l1899_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15162,7 +23555,13 @@ fn c1887_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1900 fn c1888_l1900_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1888_l1900_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15170,7 +23569,13 @@ fn c1888_l1900_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1901 fn c1889_l1901_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1889_l1901_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15178,7 +23583,13 @@ fn c1889_l1901_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1902 fn c1890_l1902_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1890_l1902_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15186,7 +23597,13 @@ fn c1890_l1902_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1903 fn c1891_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1891_l1903_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15194,7 +23611,13 @@ fn c1891_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1904 fn c1892_l1904_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1892_l1904_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15202,7 +23625,10 @@ fn c1892_l1904_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1905 fn c1893_l1905_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1893_l1905_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15234,7 +23660,10 @@ fn c1896_l1908_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1909 fn c1897_l1909_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1897_l1909_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15266,7 +23695,10 @@ fn c1900_l1912_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1913 fn c1901_l1913_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1901_l1913_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15274,7 +23706,10 @@ fn c1901_l1913_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1914 fn c1902_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1902_l1914_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15282,7 +23717,10 @@ fn c1902_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1915 fn c1903_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1903_l1915_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15290,7 +23728,10 @@ fn c1903_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1916 fn c1904_l1916_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1904_l1916_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15298,7 +23739,13 @@ fn c1904_l1916_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1917 fn c1905_l1917_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1905_l1917_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15306,7 +23753,13 @@ fn c1905_l1917_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1918 fn c1906_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1906_l1918_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15314,7 +23767,13 @@ fn c1906_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1919 fn c1907_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1907_l1919_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15322,7 +23781,13 @@ fn c1907_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1920 fn c1908_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1908_l1920_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15330,7 +23795,10 @@ fn c1908_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1921 fn c1909_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1909_l1921_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15338,7 +23806,10 @@ fn c1909_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1922 fn c1910_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1910_l1922_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "gt", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15346,7 +23817,10 @@ fn c1910_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1923 fn c1911_l1923_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1911_l1923_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15354,7 +23828,10 @@ fn c1911_l1923_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1924 fn c1912_l1924_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1912_l1924_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "gt", + &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15362,7 +23839,13 @@ fn c1912_l1924_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1925 fn c1913_l1925_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1913_l1925_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15370,7 +23853,13 @@ fn c1913_l1925_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1926 fn c1914_l1926_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1914_l1926_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15378,7 +23867,13 @@ fn c1914_l1926_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1927 fn c1915_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1915_l1927_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15386,7 +23881,13 @@ fn c1915_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1928 fn c1916_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1916_l1928_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15394,7 +23895,13 @@ fn c1916_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1929 fn c1917_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1917_l1929_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15402,7 +23909,13 @@ fn c1917_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1930 fn c1918_l1930_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1918_l1930_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15410,7 +23923,13 @@ fn c1918_l1930_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1931 fn c1919_l1931_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1919_l1931_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15418,7 +23937,13 @@ fn c1919_l1931_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1932 fn c1920_l1932_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1920_l1932_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15426,7 +23951,13 @@ fn c1920_l1932_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1933 fn c1921_l1933_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1921_l1933_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15434,7 +23965,13 @@ fn c1921_l1933_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1934 fn c1922_l1934_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1922_l1934_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15442,7 +23979,10 @@ fn c1922_l1934_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1935 fn c1923_l1935_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1923_l1935_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15450,7 +23990,10 @@ fn c1923_l1935_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1936 fn c1924_l1936_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1924_l1936_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15458,7 +24001,13 @@ fn c1924_l1936_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1937 fn c1925_l1937_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1925_l1937_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15466,7 +24015,13 @@ fn c1925_l1937_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1938 fn c1926_l1938_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1926_l1938_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15474,7 +24029,10 @@ fn c1926_l1938_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1939 fn c1927_l1939_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1927_l1939_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15482,7 +24040,10 @@ fn c1927_l1939_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1940 fn c1928_l1940_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1928_l1940_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15490,7 +24051,13 @@ fn c1928_l1940_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1941 fn c1929_l1941_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1929_l1941_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15498,7 +24065,13 @@ fn c1929_l1941_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1942 fn c1930_l1942_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1930_l1942_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15506,7 +24079,13 @@ fn c1930_l1942_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1943 fn c1931_l1943_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1931_l1943_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15514,7 +24093,13 @@ fn c1931_l1943_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1944 fn c1932_l1944_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1932_l1944_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15522,7 +24107,13 @@ fn c1932_l1944_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1945 fn c1933_l1945_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1933_l1945_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15530,7 +24121,13 @@ fn c1933_l1945_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1946 fn c1934_l1946_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1934_l1946_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15538,7 +24135,13 @@ fn c1934_l1946_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1947 fn c1935_l1947_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1935_l1947_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15546,7 +24149,13 @@ fn c1935_l1947_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1948 fn c1936_l1948_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1936_l1948_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15554,7 +24163,13 @@ fn c1936_l1948_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1949 fn c1937_l1949_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1937_l1949_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15562,7 +24177,13 @@ fn c1937_l1949_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1950 fn c1938_l1950_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1938_l1950_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15570,7 +24191,13 @@ fn c1938_l1950_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1951 fn c1939_l1951_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1939_l1951_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15578,7 +24205,13 @@ fn c1939_l1951_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1952 fn c1940_l1952_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1940_l1952_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15586,7 +24219,13 @@ fn c1940_l1952_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1953 fn c1941_l1953_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1941_l1953_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15594,7 +24233,13 @@ fn c1941_l1953_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1954 fn c1942_l1954_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1942_l1954_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15602,7 +24247,13 @@ fn c1942_l1954_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1955 fn c1943_l1955_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1943_l1955_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15610,7 +24261,13 @@ fn c1943_l1955_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1956 fn c1944_l1956_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1944_l1956_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15618,7 +24275,13 @@ fn c1944_l1956_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1957 fn c1945_l1957_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1945_l1957_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15626,7 +24289,13 @@ fn c1945_l1957_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1958 fn c1946_l1958_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1946_l1958_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15634,7 +24303,10 @@ fn c1946_l1958_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1959 fn c1947_l1959_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1947_l1959_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15642,7 +24314,10 @@ fn c1947_l1959_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1960 fn c1948_l1960_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1948_l1960_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15650,7 +24325,13 @@ fn c1948_l1960_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1961 fn c1949_l1961_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1949_l1961_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15658,7 +24339,13 @@ fn c1949_l1961_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1962 fn c1950_l1962_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1950_l1962_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15666,7 +24353,10 @@ fn c1950_l1962_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1963 fn c1951_l1963_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1951_l1963_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15674,7 +24364,10 @@ fn c1951_l1963_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1964 fn c1952_l1964_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1952_l1964_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15682,7 +24375,13 @@ fn c1952_l1964_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1965 fn c1953_l1965_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1953_l1965_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15690,7 +24389,13 @@ fn c1953_l1965_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1966 fn c1954_l1966_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1954_l1966_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15698,7 +24403,10 @@ fn c1954_l1966_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1967 fn c1955_l1967_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1955_l1967_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15706,7 +24414,10 @@ fn c1955_l1967_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1968 fn c1956_l1968_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1956_l1968_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15714,7 +24425,13 @@ fn c1956_l1968_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1969 fn c1957_l1969_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1957_l1969_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15722,7 +24439,13 @@ fn c1957_l1969_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1970 fn c1958_l1970_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1958_l1970_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15730,7 +24453,10 @@ fn c1958_l1970_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1971 fn c1959_l1971_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1959_l1971_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15738,7 +24464,10 @@ fn c1959_l1971_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1972 fn c1960_l1972_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1960_l1972_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]); + let result = instance.call( + "gt", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15746,7 +24475,13 @@ fn c1960_l1972_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1973 fn c1961_l1973_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1961_l1973_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15754,7 +24489,13 @@ fn c1961_l1973_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1974 fn c1962_l1974_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1962_l1974_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15762,7 +24503,13 @@ fn c1962_l1974_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1975 fn c1963_l1975_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1963_l1975_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15770,7 +24517,13 @@ fn c1963_l1975_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1976 fn c1964_l1976_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1964_l1976_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15778,7 +24531,13 @@ fn c1964_l1976_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1977 fn c1965_l1977_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1965_l1977_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15786,7 +24545,13 @@ fn c1965_l1977_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1978 fn c1966_l1978_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1966_l1978_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15794,7 +24559,13 @@ fn c1966_l1978_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1979 fn c1967_l1979_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1967_l1979_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15802,7 +24573,13 @@ fn c1967_l1979_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1980 fn c1968_l1980_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1968_l1980_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15810,7 +24587,13 @@ fn c1968_l1980_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1981 fn c1969_l1981_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1969_l1981_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15818,7 +24601,13 @@ fn c1969_l1981_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1982 fn c1970_l1982_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1970_l1982_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15826,7 +24615,13 @@ fn c1970_l1982_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1983 fn c1971_l1983_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1971_l1983_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15834,7 +24629,13 @@ fn c1971_l1983_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1984 fn c1972_l1984_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1972_l1984_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15842,7 +24643,13 @@ fn c1972_l1984_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1985 fn c1973_l1985_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1973_l1985_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15850,7 +24657,13 @@ fn c1973_l1985_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1986 fn c1974_l1986_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1974_l1986_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15858,7 +24671,13 @@ fn c1974_l1986_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1987 fn c1975_l1987_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1975_l1987_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15866,7 +24685,13 @@ fn c1975_l1987_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1988 fn c1976_l1988_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1976_l1988_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15874,7 +24699,13 @@ fn c1976_l1988_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1989 fn c1977_l1989_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1977_l1989_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15882,7 +24713,13 @@ fn c1977_l1989_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1990 fn c1978_l1990_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1978_l1990_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15890,7 +24727,13 @@ fn c1978_l1990_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1991 fn c1979_l1991_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1979_l1991_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15898,7 +24741,13 @@ fn c1979_l1991_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1992 fn c1980_l1992_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1980_l1992_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15906,7 +24755,13 @@ fn c1980_l1992_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1993 fn c1981_l1993_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1981_l1993_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15914,7 +24769,13 @@ fn c1981_l1993_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1994 fn c1982_l1994_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1982_l1994_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15922,7 +24783,13 @@ fn c1982_l1994_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1995 fn c1983_l1995_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1983_l1995_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15930,7 +24797,13 @@ fn c1983_l1995_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1996 fn c1984_l1996_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1984_l1996_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15938,7 +24811,13 @@ fn c1984_l1996_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1997 fn c1985_l1997_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1985_l1997_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15946,7 +24825,13 @@ fn c1985_l1997_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1998 fn c1986_l1998_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1986_l1998_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15954,7 +24839,13 @@ fn c1986_l1998_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1999 fn c1987_l1999_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1987_l1999_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15962,7 +24853,13 @@ fn c1987_l1999_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2000 fn c1988_l2000_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1988_l2000_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15970,7 +24867,13 @@ fn c1988_l2000_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2001 fn c1989_l2001_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1989_l2001_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15978,7 +24881,13 @@ fn c1989_l2001_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2002 fn c1990_l2002_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1990_l2002_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15986,7 +24895,13 @@ fn c1990_l2002_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2003 fn c1991_l2003_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1991_l2003_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15994,7 +24909,13 @@ fn c1991_l2003_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2004 fn c1992_l2004_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1992_l2004_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16002,7 +24923,13 @@ fn c1992_l2004_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2005 fn c1993_l2005_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1993_l2005_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16010,7 +24937,13 @@ fn c1993_l2005_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2006 fn c1994_l2006_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1994_l2006_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16018,7 +24951,13 @@ fn c1994_l2006_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2007 fn c1995_l2007_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1995_l2007_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16026,7 +24965,13 @@ fn c1995_l2007_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2008 fn c1996_l2008_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1996_l2008_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16034,7 +24979,13 @@ fn c1996_l2008_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2009 fn c1997_l2009_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1997_l2009_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16042,7 +24993,13 @@ fn c1997_l2009_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2010 fn c1998_l2010_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1998_l2010_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16050,7 +25007,13 @@ fn c1998_l2010_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2011 fn c1999_l2011_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1999_l2011_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16058,7 +25021,13 @@ fn c1999_l2011_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2012 fn c2000_l2012_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2000_l2012_action_invoke"); - let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "gt", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16098,7 +25067,13 @@ fn c2004_l2016_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2017 fn c2005_l2017_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2005_l2017_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16106,7 +25081,13 @@ fn c2005_l2017_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2018 fn c2006_l2018_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2006_l2018_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16114,7 +25095,13 @@ fn c2006_l2018_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2019 fn c2007_l2019_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2007_l2019_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16122,7 +25109,13 @@ fn c2007_l2019_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2020 fn c2008_l2020_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2008_l2020_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16130,7 +25123,13 @@ fn c2008_l2020_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2021 fn c2009_l2021_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2009_l2021_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16138,7 +25137,13 @@ fn c2009_l2021_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2022 fn c2010_l2022_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2010_l2022_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16146,7 +25151,13 @@ fn c2010_l2022_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2023 fn c2011_l2023_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2011_l2023_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16154,7 +25165,13 @@ fn c2011_l2023_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2024 fn c2012_l2024_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2012_l2024_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16258,7 +25275,13 @@ fn c2024_l2036_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2037 fn c2025_l2037_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2025_l2037_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16266,7 +25289,13 @@ fn c2025_l2037_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2038 fn c2026_l2038_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2026_l2038_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16274,7 +25303,13 @@ fn c2026_l2038_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2039 fn c2027_l2039_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2027_l2039_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16282,7 +25317,13 @@ fn c2027_l2039_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2040 fn c2028_l2040_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2028_l2040_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16290,7 +25331,10 @@ fn c2028_l2040_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2041 fn c2029_l2041_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2029_l2041_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[Value::F32((-0.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16322,7 +25366,13 @@ fn c2032_l2044_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2045 fn c2033_l2045_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2033_l2045_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16330,7 +25380,13 @@ fn c2033_l2045_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2046 fn c2034_l2046_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2034_l2046_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16338,7 +25394,13 @@ fn c2034_l2046_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2047 fn c2035_l2047_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2035_l2047_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16346,7 +25408,13 @@ fn c2035_l2047_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2048 fn c2036_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2036_l2048_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16354,7 +25422,10 @@ fn c2036_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2049 fn c2037_l2049_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2037_l2049_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16362,7 +25433,10 @@ fn c2037_l2049_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2050 fn c2038_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2038_l2050_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16370,7 +25444,10 @@ fn c2038_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2051 fn c2039_l2051_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2039_l2051_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16378,7 +25455,10 @@ fn c2039_l2051_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2052 fn c2040_l2052_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2040_l2052_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16386,7 +25466,13 @@ fn c2040_l2052_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2053 fn c2041_l2053_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2041_l2053_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16394,7 +25480,13 @@ fn c2041_l2053_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2054 fn c2042_l2054_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2042_l2054_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16402,7 +25494,13 @@ fn c2042_l2054_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2055 fn c2043_l2055_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2043_l2055_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16410,7 +25508,13 @@ fn c2043_l2055_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2056 fn c2044_l2056_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2044_l2056_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16418,7 +25522,13 @@ fn c2044_l2056_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2057 fn c2045_l2057_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2045_l2057_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16426,7 +25536,13 @@ fn c2045_l2057_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2058 fn c2046_l2058_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2046_l2058_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16434,7 +25550,13 @@ fn c2046_l2058_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2059 fn c2047_l2059_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2047_l2059_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16442,7 +25564,13 @@ fn c2047_l2059_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2060 fn c2048_l2060_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2048_l2060_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16450,7 +25578,13 @@ fn c2048_l2060_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2061 fn c2049_l2061_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2049_l2061_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16458,7 +25592,13 @@ fn c2049_l2061_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2062 fn c2050_l2062_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2050_l2062_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16466,7 +25606,13 @@ fn c2050_l2062_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2063 fn c2051_l2063_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2051_l2063_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16474,7 +25620,13 @@ fn c2051_l2063_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2064 fn c2052_l2064_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2052_l2064_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16482,7 +25634,13 @@ fn c2052_l2064_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2065 fn c2053_l2065_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2053_l2065_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16490,7 +25648,13 @@ fn c2053_l2065_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2066 fn c2054_l2066_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2054_l2066_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16498,7 +25662,13 @@ fn c2054_l2066_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2067 fn c2055_l2067_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2055_l2067_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16506,7 +25676,13 @@ fn c2055_l2067_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2068 fn c2056_l2068_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2056_l2068_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16514,7 +25690,13 @@ fn c2056_l2068_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2069 fn c2057_l2069_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2057_l2069_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16522,7 +25704,13 @@ fn c2057_l2069_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2070 fn c2058_l2070_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2058_l2070_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16530,7 +25718,13 @@ fn c2058_l2070_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2071 fn c2059_l2071_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2059_l2071_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16538,7 +25732,13 @@ fn c2059_l2071_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2072 fn c2060_l2072_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2060_l2072_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16546,7 +25746,13 @@ fn c2060_l2072_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2073 fn c2061_l2073_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2061_l2073_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16554,7 +25760,13 @@ fn c2061_l2073_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2074 fn c2062_l2074_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2062_l2074_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16562,7 +25774,13 @@ fn c2062_l2074_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2075 fn c2063_l2075_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2063_l2075_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16570,7 +25788,13 @@ fn c2063_l2075_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2076 fn c2064_l2076_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2064_l2076_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16578,7 +25802,13 @@ fn c2064_l2076_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2077 fn c2065_l2077_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2065_l2077_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16586,7 +25816,13 @@ fn c2065_l2077_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2078 fn c2066_l2078_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2066_l2078_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16594,7 +25830,13 @@ fn c2066_l2078_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2079 fn c2067_l2079_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2067_l2079_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16602,7 +25844,13 @@ fn c2067_l2079_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2080 fn c2068_l2080_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2068_l2080_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16610,7 +25858,13 @@ fn c2068_l2080_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2081 fn c2069_l2081_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2069_l2081_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16618,7 +25872,13 @@ fn c2069_l2081_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2082 fn c2070_l2082_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2070_l2082_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16626,7 +25886,13 @@ fn c2070_l2082_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2083 fn c2071_l2083_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2071_l2083_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16634,7 +25900,13 @@ fn c2071_l2083_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2084 fn c2072_l2084_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2072_l2084_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16642,7 +25914,13 @@ fn c2072_l2084_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2085 fn c2073_l2085_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2073_l2085_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16650,7 +25928,13 @@ fn c2073_l2085_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2086 fn c2074_l2086_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2074_l2086_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16658,7 +25942,13 @@ fn c2074_l2086_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2087 fn c2075_l2087_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2075_l2087_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16666,7 +25956,13 @@ fn c2075_l2087_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2088 fn c2076_l2088_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2076_l2088_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16674,7 +25970,13 @@ fn c2076_l2088_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2089 fn c2077_l2089_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2077_l2089_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16682,7 +25984,13 @@ fn c2077_l2089_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2090 fn c2078_l2090_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2078_l2090_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16690,7 +25998,13 @@ fn c2078_l2090_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2091 fn c2079_l2091_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2079_l2091_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16698,7 +26012,13 @@ fn c2079_l2091_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2092 fn c2080_l2092_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2080_l2092_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16706,7 +26026,13 @@ fn c2080_l2092_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2093 fn c2081_l2093_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2081_l2093_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16714,7 +26040,13 @@ fn c2081_l2093_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2094 fn c2082_l2094_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2082_l2094_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16722,7 +26054,13 @@ fn c2082_l2094_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2095 fn c2083_l2095_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2083_l2095_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16730,7 +26068,13 @@ fn c2083_l2095_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2096 fn c2084_l2096_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2084_l2096_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16738,7 +26082,13 @@ fn c2084_l2096_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2097 fn c2085_l2097_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2085_l2097_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16746,7 +26096,13 @@ fn c2085_l2097_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2098 fn c2086_l2098_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2086_l2098_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16754,7 +26110,13 @@ fn c2086_l2098_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2099 fn c2087_l2099_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2087_l2099_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16762,7 +26124,13 @@ fn c2087_l2099_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2100 fn c2088_l2100_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2088_l2100_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16770,7 +26138,13 @@ fn c2088_l2100_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2101 fn c2089_l2101_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2089_l2101_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16778,7 +26152,13 @@ fn c2089_l2101_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2102 fn c2090_l2102_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2090_l2102_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16786,7 +26166,13 @@ fn c2090_l2102_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2103 fn c2091_l2103_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2091_l2103_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16794,7 +26180,13 @@ fn c2091_l2103_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2104 fn c2092_l2104_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2092_l2104_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16802,7 +26194,13 @@ fn c2092_l2104_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2105 fn c2093_l2105_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2093_l2105_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16810,7 +26208,13 @@ fn c2093_l2105_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2106 fn c2094_l2106_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2094_l2106_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16818,7 +26222,13 @@ fn c2094_l2106_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2107 fn c2095_l2107_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2095_l2107_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16826,7 +26236,13 @@ fn c2095_l2107_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2108 fn c2096_l2108_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2096_l2108_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16834,7 +26250,13 @@ fn c2096_l2108_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2109 fn c2097_l2109_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2097_l2109_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16842,7 +26264,13 @@ fn c2097_l2109_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2110 fn c2098_l2110_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2098_l2110_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16850,7 +26278,13 @@ fn c2098_l2110_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2111 fn c2099_l2111_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2099_l2111_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16858,7 +26292,13 @@ fn c2099_l2111_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2112 fn c2100_l2112_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2100_l2112_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16866,7 +26306,13 @@ fn c2100_l2112_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2113 fn c2101_l2113_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2101_l2113_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16874,7 +26320,13 @@ fn c2101_l2113_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2114 fn c2102_l2114_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2102_l2114_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16882,7 +26334,13 @@ fn c2102_l2114_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2115 fn c2103_l2115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2103_l2115_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16890,7 +26348,13 @@ fn c2103_l2115_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2116 fn c2104_l2116_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2104_l2116_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16898,7 +26362,13 @@ fn c2104_l2116_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2117 fn c2105_l2117_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2105_l2117_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16906,7 +26376,13 @@ fn c2105_l2117_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2118 fn c2106_l2118_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2106_l2118_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16914,7 +26390,13 @@ fn c2106_l2118_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2119 fn c2107_l2119_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2107_l2119_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16922,7 +26404,13 @@ fn c2107_l2119_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2120 fn c2108_l2120_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2108_l2120_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16930,7 +26418,13 @@ fn c2108_l2120_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2121 fn c2109_l2121_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2109_l2121_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16938,7 +26432,13 @@ fn c2109_l2121_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2122 fn c2110_l2122_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2110_l2122_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16946,7 +26446,13 @@ fn c2110_l2122_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2123 fn c2111_l2123_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2111_l2123_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16954,7 +26460,13 @@ fn c2111_l2123_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2124 fn c2112_l2124_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2112_l2124_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16962,7 +26474,13 @@ fn c2112_l2124_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2125 fn c2113_l2125_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2113_l2125_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16970,7 +26488,13 @@ fn c2113_l2125_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2126 fn c2114_l2126_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2114_l2126_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16978,7 +26502,13 @@ fn c2114_l2126_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2127 fn c2115_l2127_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2115_l2127_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16986,7 +26516,13 @@ fn c2115_l2127_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2128 fn c2116_l2128_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2116_l2128_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16994,7 +26530,13 @@ fn c2116_l2128_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2129 fn c2117_l2129_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2117_l2129_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17002,7 +26544,13 @@ fn c2117_l2129_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2130 fn c2118_l2130_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2118_l2130_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17010,7 +26558,13 @@ fn c2118_l2130_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2131 fn c2119_l2131_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2119_l2131_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17018,7 +26572,13 @@ fn c2119_l2131_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2132 fn c2120_l2132_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2120_l2132_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17058,7 +26618,13 @@ fn c2124_l2136_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2137 fn c2125_l2137_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2125_l2137_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17066,7 +26632,13 @@ fn c2125_l2137_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2138 fn c2126_l2138_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2126_l2138_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17074,7 +26646,13 @@ fn c2126_l2138_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2139 fn c2127_l2139_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2127_l2139_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17082,7 +26660,13 @@ fn c2127_l2139_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2140 fn c2128_l2140_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2128_l2140_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17090,7 +26674,13 @@ fn c2128_l2140_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2141 fn c2129_l2141_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2129_l2141_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17098,7 +26688,13 @@ fn c2129_l2141_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2142 fn c2130_l2142_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2130_l2142_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17106,7 +26702,13 @@ fn c2130_l2142_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2143 fn c2131_l2143_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2131_l2143_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.5f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17114,7 +26716,13 @@ fn c2131_l2143_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2144 fn c2132_l2144_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2132_l2144_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.5f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17218,7 +26826,13 @@ fn c2144_l2156_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2157 fn c2145_l2157_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2145_l2157_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17226,7 +26840,13 @@ fn c2145_l2157_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2158 fn c2146_l2158_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2146_l2158_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17234,7 +26854,13 @@ fn c2146_l2158_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2159 fn c2147_l2159_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2147_l2159_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.5f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17242,7 +26868,13 @@ fn c2147_l2159_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2160 fn c2148_l2160_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2148_l2160_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((0.5f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17250,7 +26882,10 @@ fn c2148_l2160_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2161 fn c2149_l2161_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2149_l2161_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[Value::F32((-0.5f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17282,7 +26917,13 @@ fn c2152_l2164_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2165 fn c2153_l2165_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2153_l2165_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17290,7 +26931,13 @@ fn c2153_l2165_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2166 fn c2154_l2166_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2154_l2166_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17298,7 +26945,13 @@ fn c2154_l2166_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2167 fn c2155_l2167_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2155_l2167_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17306,7 +26959,13 @@ fn c2155_l2167_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2168 fn c2156_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2156_l2168_action_invoke"); - let result = instance.call("ge", &[Value::F32((-0.5f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32((-0.5f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17314,7 +26973,10 @@ fn c2156_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2169 fn c2157_l2169_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2157_l2169_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17322,7 +26984,10 @@ fn c2157_l2169_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2170 fn c2158_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2158_l2170_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17330,7 +26995,10 @@ fn c2158_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2171 fn c2159_l2171_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2159_l2171_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17338,7 +27006,10 @@ fn c2159_l2171_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2172 fn c2160_l2172_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2160_l2172_action_invoke"); - let result = instance.call("ge", &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[Value::F32((0.5f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17378,7 +27049,13 @@ fn c2164_l2176_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2177 fn c2165_l2177_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2165_l2177_action_invoke"); - let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17386,7 +27063,13 @@ fn c2165_l2177_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2178 fn c2166_l2178_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2166_l2178_action_invoke"); - let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17394,7 +27077,13 @@ fn c2166_l2178_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2179 fn c2167_l2179_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2167_l2179_action_invoke"); - let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17402,7 +27091,13 @@ fn c2167_l2179_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2180 fn c2168_l2180_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2168_l2180_action_invoke"); - let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17410,7 +27105,13 @@ fn c2168_l2180_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2181 fn c2169_l2181_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2169_l2181_action_invoke"); - let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17418,7 +27119,13 @@ fn c2169_l2181_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2182 fn c2170_l2182_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2170_l2182_action_invoke"); - let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17426,7 +27133,13 @@ fn c2170_l2182_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2183 fn c2171_l2183_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2171_l2183_action_invoke"); - let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((1.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17434,7 +27147,13 @@ fn c2171_l2183_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2184 fn c2172_l2184_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2172_l2184_action_invoke"); - let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17538,7 +27257,13 @@ fn c2184_l2196_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2197 fn c2185_l2197_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2185_l2197_action_invoke"); - let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17546,7 +27271,13 @@ fn c2185_l2197_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2198 fn c2186_l2198_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2186_l2198_action_invoke"); - let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17554,7 +27285,13 @@ fn c2186_l2198_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2199 fn c2187_l2199_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2187_l2199_action_invoke"); - let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((1.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17562,7 +27299,13 @@ fn c2187_l2199_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2200 fn c2188_l2200_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2188_l2200_action_invoke"); - let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((1.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17570,7 +27313,10 @@ fn c2188_l2200_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2201 fn c2189_l2201_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2189_l2201_action_invoke"); - let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[Value::F32((-1.0f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17602,7 +27348,13 @@ fn c2192_l2204_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2205 fn c2193_l2205_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2193_l2205_action_invoke"); - let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17610,7 +27362,13 @@ fn c2193_l2205_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2206 fn c2194_l2206_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2194_l2206_action_invoke"); - let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17618,7 +27376,13 @@ fn c2194_l2206_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2207 fn c2195_l2207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2195_l2207_action_invoke"); - let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17626,7 +27390,13 @@ fn c2195_l2207_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2208 fn c2196_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2196_l2208_action_invoke"); - let result = instance.call("ge", &[Value::F32((-1.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32((-1.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17634,7 +27404,10 @@ fn c2196_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2209 fn c2197_l2209_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2197_l2209_action_invoke"); - let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4290772992))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17642,7 +27415,10 @@ fn c2197_l2209_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2210 fn c2198_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2198_l2210_action_invoke"); - let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(4288675840))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17650,7 +27426,10 @@ fn c2198_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2211 fn c2199_l2211_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2199_l2211_action_invoke"); - let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17658,7 +27437,10 @@ fn c2199_l2211_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2212 fn c2200_l2212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2200_l2212_action_invoke"); - let result = instance.call("ge", &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[Value::F32((1.0f32)), Value::F32(f32::from_bits(2141192192))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17698,7 +27480,13 @@ fn c2204_l2216_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2217 fn c2205_l2217_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2205_l2217_action_invoke"); - let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17706,7 +27494,13 @@ fn c2205_l2217_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2218 fn c2206_l2218_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2206_l2218_action_invoke"); - let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17714,7 +27508,13 @@ fn c2206_l2218_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2219 fn c2207_l2219_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2207_l2219_action_invoke"); - let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17722,7 +27522,13 @@ fn c2207_l2219_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2220 fn c2208_l2220_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2208_l2220_action_invoke"); - let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17730,7 +27536,13 @@ fn c2208_l2220_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2221 fn c2209_l2221_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2209_l2221_action_invoke"); - let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17738,7 +27550,13 @@ fn c2209_l2221_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2222 fn c2210_l2222_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2210_l2222_action_invoke"); - let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17746,7 +27564,13 @@ fn c2210_l2222_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2223 fn c2211_l2223_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2211_l2223_action_invoke"); - let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((6.2831855f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17754,7 +27578,13 @@ fn c2211_l2223_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2224 fn c2212_l2224_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2212_l2224_action_invoke"); - let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((6.2831855f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17826,7 +27656,10 @@ fn c2220_l2232_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2233 fn c2221_l2233_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2221_l2233_action_invoke"); - let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ge", + &[Value::F32((-6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17834,7 +27667,10 @@ fn c2221_l2233_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2234 fn c2222_l2234_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2222_l2234_action_invoke"); - let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ge", + &[Value::F32((-6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17842,7 +27678,10 @@ fn c2222_l2234_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2235 fn c2223_l2235_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2223_l2235_action_invoke"); - let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ge", + &[Value::F32((6.2831855f32)), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17850,7 +27689,10 @@ fn c2223_l2235_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2236 fn c2224_l2236_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2224_l2236_action_invoke"); - let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ge", + &[Value::F32((6.2831855f32)), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17858,7 +27700,13 @@ fn c2224_l2236_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2237 fn c2225_l2237_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2225_l2237_action_invoke"); - let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17866,7 +27714,13 @@ fn c2225_l2237_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2238 fn c2226_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2226_l2238_action_invoke"); - let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17874,7 +27728,13 @@ fn c2226_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2239 fn c2227_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2227_l2239_action_invoke"); - let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((6.2831855f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17882,7 +27742,13 @@ fn c2227_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2240 fn c2228_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2228_l2240_action_invoke"); - let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((6.2831855f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17890,7 +27756,10 @@ fn c2228_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2241 fn c2229_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2229_l2241_action_invoke"); - let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[Value::F32((-6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17898,7 +27767,10 @@ fn c2229_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2242 fn c2230_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2230_l2242_action_invoke"); - let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ge", + &[Value::F32((-6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17906,7 +27778,10 @@ fn c2230_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2243 fn c2231_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2231_l2243_action_invoke"); - let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[Value::F32((6.2831855f32)), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17914,7 +27789,10 @@ fn c2231_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2244 fn c2232_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2232_l2244_action_invoke"); - let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ge", + &[Value::F32((6.2831855f32)), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17922,7 +27800,13 @@ fn c2232_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2245 fn c2233_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2233_l2245_action_invoke"); - let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17930,7 +27814,13 @@ fn c2233_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2246 fn c2234_l2246_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2234_l2246_action_invoke"); - let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17938,7 +27828,13 @@ fn c2234_l2246_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2247 fn c2235_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2235_l2247_action_invoke"); - let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17946,7 +27842,13 @@ fn c2235_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2248 fn c2236_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2236_l2248_action_invoke"); - let result = instance.call("ge", &[Value::F32((-6.2831855f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32((-6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17954,7 +27856,13 @@ fn c2236_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2249 fn c2237_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2237_l2249_action_invoke"); - let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17962,7 +27870,13 @@ fn c2237_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2250 fn c2238_l2250_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2238_l2250_action_invoke"); - let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17970,7 +27884,13 @@ fn c2238_l2250_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2251 fn c2239_l2251_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2239_l2251_action_invoke"); - let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17978,7 +27898,13 @@ fn c2239_l2251_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2252 fn c2240_l2252_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2240_l2252_action_invoke"); - let result = instance.call("ge", &[Value::F32((6.2831855f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32((6.2831855f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17986,7 +27912,13 @@ fn c2240_l2252_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2253 fn c2241_l2253_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2241_l2253_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17994,7 +27926,13 @@ fn c2241_l2253_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2254 fn c2242_l2254_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2242_l2254_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18002,7 +27940,13 @@ fn c2242_l2254_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2255 fn c2243_l2255_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2243_l2255_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18010,7 +27954,13 @@ fn c2243_l2255_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2256 fn c2244_l2256_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2244_l2256_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18018,7 +27968,13 @@ fn c2244_l2256_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2257 fn c2245_l2257_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2245_l2257_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18026,7 +27982,13 @@ fn c2245_l2257_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2258 fn c2246_l2258_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2246_l2258_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18034,7 +27996,13 @@ fn c2246_l2258_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2259 fn c2247_l2259_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2247_l2259_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18042,7 +28010,13 @@ fn c2247_l2259_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2260 fn c2248_l2260_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2248_l2260_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18050,7 +28024,13 @@ fn c2248_l2260_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2261 fn c2249_l2261_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2249_l2261_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18058,7 +28038,13 @@ fn c2249_l2261_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2262 fn c2250_l2262_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2250_l2262_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18066,7 +28052,13 @@ fn c2250_l2262_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2263 fn c2251_l2263_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2251_l2263_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18074,7 +28066,13 @@ fn c2251_l2263_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2264 fn c2252_l2264_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2252_l2264_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18082,7 +28080,13 @@ fn c2252_l2264_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2265 fn c2253_l2265_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2253_l2265_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18090,7 +28094,13 @@ fn c2253_l2265_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2266 fn c2254_l2266_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2254_l2266_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18098,7 +28108,13 @@ fn c2254_l2266_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2267 fn c2255_l2267_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2255_l2267_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18106,7 +28122,13 @@ fn c2255_l2267_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2268 fn c2256_l2268_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2256_l2268_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18114,7 +28136,13 @@ fn c2256_l2268_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2269 fn c2257_l2269_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2257_l2269_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18122,7 +28150,13 @@ fn c2257_l2269_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2270 fn c2258_l2270_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2258_l2270_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18130,7 +28164,13 @@ fn c2258_l2270_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2271 fn c2259_l2271_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2259_l2271_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18138,7 +28178,13 @@ fn c2259_l2271_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2272 fn c2260_l2272_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2260_l2272_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18146,7 +28192,13 @@ fn c2260_l2272_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2273 fn c2261_l2273_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2261_l2273_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18154,7 +28206,13 @@ fn c2261_l2273_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2274 fn c2262_l2274_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2262_l2274_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18162,7 +28220,13 @@ fn c2262_l2274_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2275 fn c2263_l2275_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2263_l2275_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18170,7 +28234,13 @@ fn c2263_l2275_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2276 fn c2264_l2276_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2264_l2276_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18178,7 +28248,13 @@ fn c2264_l2276_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2277 fn c2265_l2277_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2265_l2277_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18186,7 +28262,13 @@ fn c2265_l2277_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2278 fn c2266_l2278_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2266_l2278_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18194,7 +28276,13 @@ fn c2266_l2278_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2279 fn c2267_l2279_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2267_l2279_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18202,7 +28290,13 @@ fn c2267_l2279_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2280 fn c2268_l2280_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2268_l2280_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18210,7 +28304,13 @@ fn c2268_l2280_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2281 fn c2269_l2281_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2269_l2281_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18218,7 +28318,13 @@ fn c2269_l2281_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2282 fn c2270_l2282_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2270_l2282_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18226,7 +28332,13 @@ fn c2270_l2282_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2283 fn c2271_l2283_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2271_l2283_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18234,7 +28346,13 @@ fn c2271_l2283_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2284 fn c2272_l2284_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2272_l2284_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18242,7 +28360,13 @@ fn c2272_l2284_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2285 fn c2273_l2285_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2273_l2285_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18250,7 +28374,13 @@ fn c2273_l2285_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2286 fn c2274_l2286_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2274_l2286_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18258,7 +28388,13 @@ fn c2274_l2286_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2287 fn c2275_l2287_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2275_l2287_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18266,7 +28402,13 @@ fn c2275_l2287_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2288 fn c2276_l2288_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2276_l2288_action_invoke"); - let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32((-340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18274,7 +28416,13 @@ fn c2276_l2288_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2289 fn c2277_l2289_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2277_l2289_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18282,7 +28430,13 @@ fn c2277_l2289_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2290 fn c2278_l2290_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2278_l2290_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18290,7 +28444,13 @@ fn c2278_l2290_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2291 fn c2279_l2291_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2279_l2291_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18298,7 +28458,13 @@ fn c2279_l2291_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2292 fn c2280_l2292_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2280_l2292_action_invoke"); - let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18306,7 +28472,10 @@ fn c2280_l2292_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2293 fn c2281_l2293_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2281_l2293_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18338,7 +28507,13 @@ fn c2284_l2296_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2297 fn c2285_l2297_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2285_l2297_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18346,7 +28521,13 @@ fn c2285_l2297_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2298 fn c2286_l2298_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2286_l2298_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18354,7 +28535,13 @@ fn c2286_l2298_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2299 fn c2287_l2299_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2287_l2299_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18362,7 +28549,13 @@ fn c2287_l2299_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2300 fn c2288_l2300_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2288_l2300_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18370,7 +28563,13 @@ fn c2288_l2300_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2301 fn c2289_l2301_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2289_l2301_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18378,7 +28577,13 @@ fn c2289_l2301_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2302 fn c2290_l2302_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2290_l2302_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18386,7 +28591,13 @@ fn c2290_l2302_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2303 fn c2291_l2303_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2291_l2303_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::INFINITY), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18394,7 +28605,13 @@ fn c2291_l2303_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2304 fn c2292_l2304_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2292_l2304_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::INFINITY), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18402,7 +28619,10 @@ fn c2292_l2304_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2305 fn c2293_l2305_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2293_l2305_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18434,7 +28654,10 @@ fn c2296_l2308_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2309 fn c2297_l2309_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2297_l2309_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18466,7 +28689,10 @@ fn c2300_l2312_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2313 fn c2301_l2313_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2301_l2313_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::NEG_INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18474,7 +28700,10 @@ fn c2301_l2313_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2314 fn c2302_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2302_l2314_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::NEG_INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18482,7 +28711,10 @@ fn c2302_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2315 fn c2303_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2303_l2315_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::INFINITY), Value::F32((-6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18490,7 +28722,10 @@ fn c2303_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2316 fn c2304_l2316_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2304_l2316_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::INFINITY), Value::F32((6.2831855f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18498,7 +28733,13 @@ fn c2304_l2316_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2317 fn c2305_l2317_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2305_l2317_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18506,7 +28747,13 @@ fn c2305_l2317_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2318 fn c2306_l2318_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2306_l2318_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18514,7 +28761,13 @@ fn c2306_l2318_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2319 fn c2307_l2319_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2307_l2319_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::INFINITY), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18522,7 +28775,13 @@ fn c2307_l2319_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2320 fn c2308_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2308_l2320_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::INFINITY), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18530,7 +28789,10 @@ fn c2308_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2321 fn c2309_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2309_l2321_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18538,7 +28800,10 @@ fn c2309_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2322 fn c2310_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2310_l2322_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ge", + &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18546,7 +28811,10 @@ fn c2310_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2323 fn c2311_l2323_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2311_l2323_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18554,7 +28822,10 @@ fn c2311_l2323_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2324 fn c2312_l2324_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2312_l2324_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ge", + &[Value::F32(f32::INFINITY), Value::F32(f32::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18562,7 +28833,13 @@ fn c2312_l2324_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2325 fn c2313_l2325_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2313_l2325_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18570,7 +28847,13 @@ fn c2313_l2325_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2326 fn c2314_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2314_l2326_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18578,7 +28861,13 @@ fn c2314_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2327 fn c2315_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2315_l2327_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18586,7 +28875,13 @@ fn c2315_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2328 fn c2316_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2316_l2328_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18594,7 +28889,13 @@ fn c2316_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2329 fn c2317_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2317_l2329_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18602,7 +28903,13 @@ fn c2317_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2330 fn c2318_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2318_l2330_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18610,7 +28917,13 @@ fn c2318_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2331 fn c2319_l2331_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2319_l2331_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18618,7 +28931,13 @@ fn c2319_l2331_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2332 fn c2320_l2332_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2320_l2332_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::INFINITY), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18626,7 +28945,13 @@ fn c2320_l2332_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2333 fn c2321_l2333_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2321_l2333_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18634,7 +28959,13 @@ fn c2321_l2333_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2334 fn c2322_l2334_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2322_l2334_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18642,7 +28973,10 @@ fn c2322_l2334_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2335 fn c2323_l2335_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2323_l2335_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18650,7 +28984,10 @@ fn c2323_l2335_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2336 fn c2324_l2336_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2324_l2336_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18658,7 +28995,13 @@ fn c2324_l2336_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2337 fn c2325_l2337_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2325_l2337_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18666,7 +29009,13 @@ fn c2325_l2337_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2338 fn c2326_l2338_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2326_l2338_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18674,7 +29023,10 @@ fn c2326_l2338_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2339 fn c2327_l2339_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2327_l2339_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18682,7 +29034,10 @@ fn c2327_l2339_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2340 fn c2328_l2340_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2328_l2340_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18690,7 +29045,13 @@ fn c2328_l2340_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2341 fn c2329_l2341_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2329_l2341_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18698,7 +29059,13 @@ fn c2329_l2341_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2342 fn c2330_l2342_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2330_l2342_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18706,7 +29073,13 @@ fn c2330_l2342_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2343 fn c2331_l2343_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2331_l2343_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18714,7 +29087,13 @@ fn c2331_l2343_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2344 fn c2332_l2344_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2332_l2344_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18722,7 +29101,13 @@ fn c2332_l2344_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2345 fn c2333_l2345_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2333_l2345_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18730,7 +29115,13 @@ fn c2333_l2345_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2346 fn c2334_l2346_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2334_l2346_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18738,7 +29129,13 @@ fn c2334_l2346_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2347 fn c2335_l2347_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2335_l2347_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18746,7 +29143,13 @@ fn c2335_l2347_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2348 fn c2336_l2348_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2336_l2348_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000000000001f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000000000001f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18754,7 +29157,13 @@ fn c2336_l2348_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2349 fn c2337_l2349_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2337_l2349_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18762,7 +29171,13 @@ fn c2337_l2349_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2350 fn c2338_l2350_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2338_l2350_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18770,7 +29185,13 @@ fn c2338_l2350_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2351 fn c2339_l2351_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2339_l2351_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18778,7 +29199,13 @@ fn c2339_l2351_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2352 fn c2340_l2352_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2340_l2352_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18786,7 +29213,13 @@ fn c2340_l2352_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2353 fn c2341_l2353_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2341_l2353_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18794,7 +29227,13 @@ fn c2341_l2353_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2354 fn c2342_l2354_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2342_l2354_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18802,7 +29241,13 @@ fn c2342_l2354_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2355 fn c2343_l2355_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2343_l2355_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18810,7 +29255,13 @@ fn c2343_l2355_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2356 fn c2344_l2356_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2344_l2356_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18818,7 +29269,13 @@ fn c2344_l2356_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2357 fn c2345_l2357_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2345_l2357_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18826,7 +29283,13 @@ fn c2345_l2357_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2358 fn c2346_l2358_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2346_l2358_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18834,7 +29297,10 @@ fn c2346_l2358_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2359 fn c2347_l2359_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2347_l2359_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18842,7 +29308,10 @@ fn c2347_l2359_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2360 fn c2348_l2360_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2348_l2360_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18850,7 +29319,13 @@ fn c2348_l2360_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2361 fn c2349_l2361_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2349_l2361_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18858,7 +29333,13 @@ fn c2349_l2361_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2362 fn c2350_l2362_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2350_l2362_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-0.5f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-0.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18866,7 +29347,10 @@ fn c2350_l2362_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2363 fn c2351_l2363_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2351_l2363_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18874,7 +29358,10 @@ fn c2351_l2363_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2364 fn c2352_l2364_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2352_l2364_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18882,7 +29369,13 @@ fn c2352_l2364_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2365 fn c2353_l2365_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2353_l2365_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18890,7 +29383,13 @@ fn c2353_l2365_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2366 fn c2354_l2366_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2354_l2366_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18898,7 +29397,10 @@ fn c2354_l2366_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2367 fn c2355_l2367_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2355_l2367_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::from_bits(4290772992)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18906,7 +29408,10 @@ fn c2355_l2367_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2368 fn c2356_l2368_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2356_l2368_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::from_bits(4288675840)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18914,7 +29419,13 @@ fn c2356_l2368_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2369 fn c2357_l2369_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2357_l2369_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18922,7 +29433,13 @@ fn c2357_l2369_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2370 fn c2358_l2370_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2358_l2370_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-1.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-1.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18930,7 +29447,10 @@ fn c2358_l2370_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2371 fn c2359_l2371_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2359_l2371_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18938,7 +29458,10 @@ fn c2359_l2371_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2372 fn c2360_l2372_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2360_l2372_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))]); + let result = instance.call( + "ge", + &[Value::F32(f32::from_bits(2141192192)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18946,7 +29469,13 @@ fn c2360_l2372_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2373 fn c2361_l2373_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2361_l2373_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18954,7 +29483,13 @@ fn c2361_l2373_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2374 fn c2362_l2374_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2362_l2374_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18962,7 +29497,13 @@ fn c2362_l2374_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2375 fn c2363_l2375_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2363_l2375_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18970,7 +29511,13 @@ fn c2363_l2375_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2376 fn c2364_l2376_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2364_l2376_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18978,7 +29525,13 @@ fn c2364_l2376_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2377 fn c2365_l2377_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2365_l2377_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18986,7 +29539,13 @@ fn c2365_l2377_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2378 fn c2366_l2378_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2366_l2378_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18994,7 +29553,13 @@ fn c2366_l2378_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2379 fn c2367_l2379_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2367_l2379_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19002,7 +29567,13 @@ fn c2367_l2379_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2380 fn c2368_l2380_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2368_l2380_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((6.2831855f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((6.2831855f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19010,7 +29581,13 @@ fn c2368_l2380_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2381 fn c2369_l2381_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2369_l2381_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19018,7 +29595,13 @@ fn c2369_l2381_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2382 fn c2370_l2382_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2370_l2382_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19026,7 +29609,13 @@ fn c2370_l2382_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2383 fn c2371_l2383_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2371_l2383_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19034,7 +29623,13 @@ fn c2371_l2383_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2384 fn c2372_l2384_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2372_l2384_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19042,7 +29637,13 @@ fn c2372_l2384_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2385 fn c2373_l2385_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2373_l2385_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19050,7 +29651,13 @@ fn c2373_l2385_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2386 fn c2374_l2386_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2374_l2386_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((-340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((-340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19058,7 +29665,13 @@ fn c2374_l2386_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2387 fn c2375_l2387_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2375_l2387_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19066,7 +29679,13 @@ fn c2375_l2387_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2388 fn c2376_l2388_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2376_l2388_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19074,7 +29693,13 @@ fn c2376_l2388_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2389 fn c2377_l2389_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2377_l2389_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19082,7 +29707,13 @@ fn c2377_l2389_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2390 fn c2378_l2390_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2378_l2390_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19090,7 +29721,13 @@ fn c2378_l2390_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2391 fn c2379_l2391_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2379_l2391_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19098,7 +29735,13 @@ fn c2379_l2391_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2392 fn c2380_l2392_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2380_l2392_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19106,7 +29749,13 @@ fn c2380_l2392_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2393 fn c2381_l2393_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2381_l2393_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19114,7 +29763,13 @@ fn c2381_l2393_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2394 fn c2382_l2394_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2382_l2394_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19122,7 +29777,13 @@ fn c2382_l2394_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2395 fn c2383_l2395_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2383_l2395_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19130,7 +29791,13 @@ fn c2383_l2395_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2396 fn c2384_l2396_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2384_l2396_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19138,7 +29805,13 @@ fn c2384_l2396_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2397 fn c2385_l2397_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2385_l2397_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19146,7 +29819,13 @@ fn c2385_l2397_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2398 fn c2386_l2398_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2386_l2398_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19154,7 +29833,13 @@ fn c2386_l2398_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2399 fn c2387_l2399_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2387_l2399_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19162,7 +29847,13 @@ fn c2387_l2399_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2400 fn c2388_l2400_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2388_l2400_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19170,7 +29861,13 @@ fn c2388_l2400_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2401 fn c2389_l2401_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2389_l2401_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19178,7 +29875,13 @@ fn c2389_l2401_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2402 fn c2390_l2402_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2390_l2402_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19186,7 +29889,13 @@ fn c2390_l2402_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2403 fn c2391_l2403_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2391_l2403_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4290772992)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19194,7 +29903,13 @@ fn c2391_l2403_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2404 fn c2392_l2404_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2392_l2404_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(4288675840)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19202,7 +29917,13 @@ fn c2392_l2404_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2405 fn c2393_l2405_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2393_l2405_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19210,7 +29931,13 @@ fn c2393_l2405_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2406 fn c2394_l2406_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2394_l2406_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4290772992)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19218,7 +29945,13 @@ fn c2394_l2406_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2407 fn c2395_l2407_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2395_l2407_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19226,7 +29959,13 @@ fn c2395_l2407_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2408 fn c2396_l2408_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2396_l2408_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(4288675840))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(4288675840)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19234,7 +29973,13 @@ fn c2396_l2408_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2409 fn c2397_l2409_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2397_l2409_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19242,7 +29987,13 @@ fn c2397_l2409_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2410 fn c2398_l2410_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2398_l2410_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19250,7 +30001,13 @@ fn c2398_l2410_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2411 fn c2399_l2411_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2399_l2411_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19258,7 +30015,13 @@ fn c2399_l2411_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2412 fn c2400_l2412_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2400_l2412_action_invoke"); - let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192)), Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "ge", + &[ + Value::F32(f32::from_bits(2141192192)), + Value::F32(f32::from_bits(2141192192)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } diff --git a/lib/runtime/tests/spectests/f64_.rs b/lib/runtime/tests/spectests/f64_.rs index 9d9f4b065..b28418b9a 100644 --- a/lib/runtime/tests/spectests/f64_.rs +++ b/lib/runtime/tests/spectests/f64_.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 5 fn create_module_1() -> Box { @@ -75,8 +71,11 @@ fn create_module_1() -> Box { (export \"nearest\" (func 10))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -247,7 +246,10 @@ fn c20_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 39 fn c21_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c21_l39_action_invoke"); - let result = instance.call("add", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "add", + &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -255,7 +257,10 @@ fn c21_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 40 fn c22_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c22_l40_action_invoke"); - let result = instance.call("add", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "add", + &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -263,7 +268,10 @@ fn c22_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 41 fn c23_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c23_l41_action_invoke"); - let result = instance.call("add", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "add", + &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -271,7 +279,10 @@ fn c23_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 42 fn c24_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c24_l42_action_invoke"); - let result = instance.call("add", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "add", + &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -311,7 +322,10 @@ fn c28_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 47 fn c29_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c29_l47_action_invoke"); - let result = instance.call("add", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -327,7 +341,10 @@ fn c30_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 49 fn c31_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c31_l49_action_invoke"); - let result = instance.call("add", &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -342,89 +359,185 @@ fn c32_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 51 fn c33_l51_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c33_l51_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c33_l51_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c33_l51_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c33_l51_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 52 fn c34_l52_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c34_l52_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c34_l52_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c34_l52_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c34_l52_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 53 fn c35_l53_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c35_l53_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c35_l53_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c35_l53_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c35_l53_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 54 fn c36_l54_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c36_l54_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c36_l54_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c36_l54_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c36_l54_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 55 fn c37_l55_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c37_l55_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c37_l55_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c37_l55_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c37_l55_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 56 fn c38_l56_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c38_l56_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c38_l56_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c38_l56_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c38_l56_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 57 fn c39_l57_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c39_l57_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c39_l57_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c39_l57_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c39_l57_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 58 fn c40_l58_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c40_l58_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c40_l58_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c40_l58_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c40_l58_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -686,89 +799,113 @@ fn c72_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 91 fn c73_l91_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c73_l91_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c73_l91_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c73_l91_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 92 fn c74_l92_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c74_l92_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c74_l92_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c74_l92_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 93 fn c75_l93_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c75_l93_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c75_l93_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c75_l93_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 94 fn c76_l94_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c76_l94_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c76_l94_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c76_l94_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 95 fn c77_l95_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c77_l95_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c77_l95_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c77_l95_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 96 fn c78_l96_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c78_l96_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c78_l96_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c78_l96_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 97 fn c79_l97_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c79_l97_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c79_l97_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c79_l97_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 98 fn c80_l98_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c80_l98_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c80_l98_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c80_l98_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -1030,89 +1167,113 @@ fn c112_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 131 fn c113_l131_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c113_l131_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c113_l131_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c113_l131_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 132 fn c114_l132_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c114_l132_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c114_l132_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c114_l132_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 133 fn c115_l133_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c115_l133_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c115_l133_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c115_l133_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 134 fn c116_l134_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c116_l134_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c116_l134_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c116_l134_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 135 fn c117_l135_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c117_l135_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c117_l135_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c117_l135_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 136 fn c118_l136_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c118_l136_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c118_l136_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c118_l136_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 137 fn c119_l137_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c119_l137_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c119_l137_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c119_l137_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 138 fn c120_l138_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c120_l138_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c120_l138_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c120_l138_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -1279,7 +1440,10 @@ fn c140_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 159 fn c141_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c141_l159_action_invoke"); - let result = instance.call("add", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "add", + &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.783185307179586f64))))); result.map(|_| ()) } @@ -1287,7 +1451,10 @@ fn c141_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 160 fn c142_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c142_l160_action_invoke"); - let result = instance.call("add", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "add", + &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((5.783185307179586f64))))); result.map(|_| ()) } @@ -1295,7 +1462,10 @@ fn c142_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 161 fn c143_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c143_l161_action_invoke"); - let result = instance.call("add", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "add", + &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-5.783185307179586f64))))); result.map(|_| ()) } @@ -1303,7 +1473,10 @@ fn c143_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 162 fn c144_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c144_l162_action_invoke"); - let result = instance.call("add", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "add", + &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.783185307179586f64))))); result.map(|_| ()) } @@ -1343,7 +1516,10 @@ fn c148_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 167 fn c149_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c149_l167_action_invoke"); - let result = instance.call("add", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -1359,7 +1535,10 @@ fn c150_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 169 fn c151_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c151_l169_action_invoke"); - let result = instance.call("add", &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -1374,89 +1553,185 @@ fn c152_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 171 fn c153_l171_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c153_l171_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c153_l171_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c153_l171_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c153_l171_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 172 fn c154_l172_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c154_l172_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c154_l172_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c154_l172_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c154_l172_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 173 fn c155_l173_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c155_l173_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c155_l173_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c155_l173_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c155_l173_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 174 fn c156_l174_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c156_l174_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c156_l174_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c156_l174_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c156_l174_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 175 fn c157_l175_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c157_l175_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c157_l175_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c157_l175_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c157_l175_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 176 fn c158_l176_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c158_l176_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c158_l176_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c158_l176_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c158_l176_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 177 fn c159_l177_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c159_l177_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c159_l177_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c159_l177_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c159_l177_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 178 fn c160_l178_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c160_l178_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c160_l178_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c160_l178_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c160_l178_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -1623,7 +1898,10 @@ fn c180_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 199 fn c181_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c181_l199_action_invoke"); - let result = instance.call("add", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "add", + &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-7.283185307179586f64))))); result.map(|_| ()) } @@ -1631,7 +1909,10 @@ fn c181_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 200 fn c182_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c182_l200_action_invoke"); - let result = instance.call("add", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "add", + &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((5.283185307179586f64))))); result.map(|_| ()) } @@ -1639,7 +1920,10 @@ fn c182_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 201 fn c183_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c183_l201_action_invoke"); - let result = instance.call("add", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "add", + &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-5.283185307179586f64))))); result.map(|_| ()) } @@ -1647,7 +1931,10 @@ fn c183_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 202 fn c184_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c184_l202_action_invoke"); - let result = instance.call("add", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "add", + &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((7.283185307179586f64))))); result.map(|_| ()) } @@ -1687,7 +1974,10 @@ fn c188_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 207 fn c189_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c189_l207_action_invoke"); - let result = instance.call("add", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -1703,7 +1993,10 @@ fn c190_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 209 fn c191_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c191_l209_action_invoke"); - let result = instance.call("add", &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -1718,96 +2011,195 @@ fn c192_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 211 fn c193_l211_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c193_l211_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c193_l211_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c193_l211_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c193_l211_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 212 fn c194_l212_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c194_l212_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c194_l212_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c194_l212_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c194_l212_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 213 fn c195_l213_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c195_l213_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c195_l213_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c195_l213_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c195_l213_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 214 fn c196_l214_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c196_l214_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c196_l214_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c196_l214_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c196_l214_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 215 fn c197_l215_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c197_l215_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c197_l215_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c197_l215_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c197_l215_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 216 fn c198_l216_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c198_l216_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c198_l216_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c198_l216_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c198_l216_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 217 fn c199_l217_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c199_l217_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c199_l217_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c199_l217_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c199_l217_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 218 fn c200_l218_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c200_l218_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c200_l218_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c200_l218_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c200_l218_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 219 fn c201_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c201_l219_action_invoke"); - let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "add", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -1815,7 +2207,10 @@ fn c201_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 220 fn c202_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c202_l220_action_invoke"); - let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "add", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -1823,7 +2218,10 @@ fn c202_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 221 fn c203_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c203_l221_action_invoke"); - let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "add", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -1831,7 +2229,10 @@ fn c203_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 222 fn c204_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c204_l222_action_invoke"); - let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "add", + &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -1903,7 +2304,10 @@ fn c212_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 231 fn c213_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c213_l231_action_invoke"); - let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "add", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.783185307179586f64))))); result.map(|_| ()) } @@ -1911,7 +2315,10 @@ fn c213_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 232 fn c214_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c214_l232_action_invoke"); - let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "add", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-5.783185307179586f64))))); result.map(|_| ()) } @@ -1919,7 +2326,10 @@ fn c214_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 233 fn c215_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c215_l233_action_invoke"); - let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "add", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((5.783185307179586f64))))); result.map(|_| ()) } @@ -1927,7 +2337,10 @@ fn c215_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 234 fn c216_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c216_l234_action_invoke"); - let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "add", + &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.783185307179586f64))))); result.map(|_| ()) } @@ -1935,7 +2348,10 @@ fn c216_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 235 fn c217_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c217_l235_action_invoke"); - let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "add", + &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-7.283185307179586f64))))); result.map(|_| ()) } @@ -1943,7 +2359,10 @@ fn c217_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 236 fn c218_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c218_l236_action_invoke"); - let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "add", + &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-5.283185307179586f64))))); result.map(|_| ()) } @@ -1951,7 +2370,10 @@ fn c218_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 237 fn c219_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c219_l237_action_invoke"); - let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "add", + &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((5.283185307179586f64))))); result.map(|_| ()) } @@ -1959,7 +2381,10 @@ fn c219_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 238 fn c220_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c220_l238_action_invoke"); - let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "add", + &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((7.283185307179586f64))))); result.map(|_| ()) } @@ -1967,7 +2392,13 @@ fn c220_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 239 fn c221_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c221_l239_action_invoke"); - let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "add", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-12.566370614359172f64))))); result.map(|_| ()) } @@ -1975,7 +2406,13 @@ fn c221_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 240 fn c222_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c222_l240_action_invoke"); - let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "add", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -1983,7 +2420,13 @@ fn c222_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 241 fn c223_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c223_l241_action_invoke"); - let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "add", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -1991,7 +2434,13 @@ fn c223_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 242 fn c224_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c224_l242_action_invoke"); - let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "add", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((12.566370614359172f64))))); result.map(|_| ()) } @@ -2031,7 +2480,13 @@ fn c228_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 247 fn c229_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c229_l247_action_invoke"); - let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2039,7 +2494,13 @@ fn c229_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 248 fn c230_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c230_l248_action_invoke"); - let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2047,7 +2508,13 @@ fn c230_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 249 fn c231_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c231_l249_action_invoke"); - let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2055,96 +2522,198 @@ fn c231_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 250 fn c232_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c232_l250_action_invoke"); - let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "add", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } // Line 251 fn c233_l251_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c233_l251_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c233_l251_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c233_l251_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c233_l251_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 252 fn c234_l252_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c234_l252_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c234_l252_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c234_l252_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c234_l252_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 253 fn c235_l253_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c235_l253_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c235_l253_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c235_l253_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c235_l253_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 254 fn c236_l254_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c236_l254_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c236_l254_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c236_l254_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c236_l254_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 255 fn c237_l255_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c237_l255_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c237_l255_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c237_l255_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c237_l255_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 256 fn c238_l256_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c238_l256_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c238_l256_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c238_l256_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c238_l256_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 257 fn c239_l257_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c239_l257_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c239_l257_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c239_l257_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c239_l257_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 258 fn c240_l258_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c240_l258_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c240_l258_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c240_l258_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c240_l258_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -2406,96 +2975,123 @@ fn c272_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 291 fn c273_l291_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c273_l291_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c273_l291_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c273_l291_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 292 fn c274_l292_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c274_l292_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c274_l292_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c274_l292_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 293 fn c275_l293_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c275_l293_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c275_l293_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c275_l293_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 294 fn c276_l294_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c276_l294_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c276_l294_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c276_l294_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 295 fn c277_l295_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c277_l295_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c277_l295_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c277_l295_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 296 fn c278_l296_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c278_l296_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c278_l296_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c278_l296_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 297 fn c279_l297_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c279_l297_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c279_l297_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c279_l297_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 298 fn c280_l298_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c280_l298_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c280_l298_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c280_l298_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 299 fn c281_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c281_l299_action_invoke"); - let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]); + let result = instance.call( + "add", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2503,7 +3099,10 @@ fn c281_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 300 fn c282_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c282_l300_action_invoke"); - let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))]); + let result = instance.call( + "add", + &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2591,7 +3190,10 @@ fn c292_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 311 fn c293_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c293_l311_action_invoke"); - let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]); + let result = instance.call( + "add", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2599,7 +3201,10 @@ fn c293_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 312 fn c294_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c294_l312_action_invoke"); - let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))]); + let result = instance.call( + "add", + &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2623,7 +3228,10 @@ fn c296_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 315 fn c297_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c297_l315_action_invoke"); - let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]); + let result = instance.call( + "add", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2631,7 +3239,10 @@ fn c297_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 316 fn c298_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c298_l316_action_invoke"); - let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))]); + let result = instance.call( + "add", + &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2655,7 +3266,13 @@ fn c300_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 319 fn c301_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c301_l319_action_invoke"); - let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "add", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2663,7 +3280,13 @@ fn c301_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 320 fn c302_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c302_l320_action_invoke"); - let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "add", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2671,7 +3294,13 @@ fn c302_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 321 fn c303_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c303_l321_action_invoke"); - let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "add", + &[ + Value::F64(f64::INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2679,7 +3308,13 @@ fn c303_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 322 fn c304_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c304_l322_action_invoke"); - let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "add", + &[ + Value::F64(f64::INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2719,1006 +3354,1870 @@ fn c308_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 327 fn c309_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c309_l327_action_invoke"); - let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "add", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } // Line 328 fn c310_l328_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c310_l328_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c310_l328_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c310_l328_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)], + ) + .unwrap() + .expect("Missing result in c310_l328_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 329 fn c311_l329_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c311_l329_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c311_l329_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c311_l329_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)], + ) + .unwrap() + .expect("Missing result in c311_l329_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 330 fn c312_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c312_l330_action_invoke"); - let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "add", + &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } // Line 331 fn c313_l331_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c313_l331_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c313_l331_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c313_l331_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c313_l331_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 332 fn c314_l332_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c314_l332_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c314_l332_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c314_l332_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c314_l332_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 333 fn c315_l333_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c315_l333_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c315_l333_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c315_l333_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c315_l333_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 334 fn c316_l334_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c316_l334_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c316_l334_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c316_l334_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c316_l334_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 335 fn c317_l335_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c317_l335_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c317_l335_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c317_l335_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c317_l335_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 336 fn c318_l336_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c318_l336_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c318_l336_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c318_l336_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c318_l336_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 337 fn c319_l337_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c319_l337_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c319_l337_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c319_l337_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c319_l337_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 338 fn c320_l338_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c320_l338_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c320_l338_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c320_l338_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c320_l338_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 339 fn c321_l339_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c321_l339_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c321_l339_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c321_l339_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c321_l339_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 340 fn c322_l340_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c322_l340_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c322_l340_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c322_l340_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c322_l340_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 341 fn c323_l341_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c323_l341_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c323_l341_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c323_l341_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c323_l341_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 342 fn c324_l342_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c324_l342_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c324_l342_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c324_l342_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c324_l342_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 343 fn c325_l343_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c325_l343_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c325_l343_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c325_l343_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c325_l343_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 344 fn c326_l344_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c326_l344_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c326_l344_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c326_l344_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c326_l344_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 345 fn c327_l345_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c327_l345_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c327_l345_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c327_l345_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c327_l345_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 346 fn c328_l346_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c328_l346_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c328_l346_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c328_l346_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c328_l346_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 347 fn c329_l347_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c329_l347_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c329_l347_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c329_l347_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 348 fn c330_l348_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c330_l348_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c330_l348_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c330_l348_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 349 fn c331_l349_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c331_l349_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c331_l349_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c331_l349_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 350 fn c332_l350_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c332_l350_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c332_l350_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c332_l350_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 351 fn c333_l351_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c333_l351_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c333_l351_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c333_l351_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 352 fn c334_l352_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c334_l352_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c334_l352_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c334_l352_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 353 fn c335_l353_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c335_l353_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c335_l353_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c335_l353_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 354 fn c336_l354_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c336_l354_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c336_l354_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c336_l354_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 355 fn c337_l355_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c337_l355_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c337_l355_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c337_l355_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 356 fn c338_l356_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c338_l356_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c338_l356_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c338_l356_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 357 fn c339_l357_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c339_l357_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c339_l357_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c339_l357_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 358 fn c340_l358_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c340_l358_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c340_l358_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c340_l358_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 359 fn c341_l359_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c341_l359_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c341_l359_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c341_l359_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 360 fn c342_l360_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c342_l360_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c342_l360_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c342_l360_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 361 fn c343_l361_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c343_l361_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c343_l361_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c343_l361_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 362 fn c344_l362_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c344_l362_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c344_l362_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c344_l362_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 363 fn c345_l363_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c345_l363_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c345_l363_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c345_l363_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c345_l363_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 364 fn c346_l364_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c346_l364_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c346_l364_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c346_l364_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c346_l364_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 365 fn c347_l365_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c347_l365_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c347_l365_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c347_l365_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c347_l365_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 366 fn c348_l366_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c348_l366_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c348_l366_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c348_l366_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c348_l366_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 367 fn c349_l367_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c349_l367_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c349_l367_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c349_l367_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c349_l367_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 368 fn c350_l368_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c350_l368_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c350_l368_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c350_l368_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c350_l368_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 369 fn c351_l369_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c351_l369_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c351_l369_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c351_l369_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c351_l369_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 370 fn c352_l370_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c352_l370_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c352_l370_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c352_l370_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c352_l370_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 371 fn c353_l371_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c353_l371_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c353_l371_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c353_l371_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c353_l371_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 372 fn c354_l372_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c354_l372_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c354_l372_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c354_l372_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c354_l372_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 373 fn c355_l373_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c355_l373_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c355_l373_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c355_l373_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c355_l373_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 374 fn c356_l374_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c356_l374_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c356_l374_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c356_l374_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c356_l374_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 375 fn c357_l375_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c357_l375_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c357_l375_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c357_l375_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c357_l375_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 376 fn c358_l376_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c358_l376_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c358_l376_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c358_l376_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c358_l376_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 377 fn c359_l377_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c359_l377_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c359_l377_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c359_l377_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c359_l377_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 378 fn c360_l378_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c360_l378_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c360_l378_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c360_l378_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c360_l378_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 379 fn c361_l379_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c361_l379_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c361_l379_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c361_l379_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c361_l379_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 380 fn c362_l380_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c362_l380_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c362_l380_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c362_l380_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c362_l380_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 381 fn c363_l381_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c363_l381_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c363_l381_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c363_l381_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c363_l381_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 382 fn c364_l382_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c364_l382_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c364_l382_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c364_l382_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c364_l382_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 383 fn c365_l383_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c365_l383_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c365_l383_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c365_l383_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c365_l383_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 384 fn c366_l384_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c366_l384_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c366_l384_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c366_l384_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c366_l384_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 385 fn c367_l385_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c367_l385_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c367_l385_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c367_l385_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c367_l385_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 386 fn c368_l386_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c368_l386_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c368_l386_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c368_l386_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c368_l386_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 387 fn c369_l387_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c369_l387_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c369_l387_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c369_l387_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 388 fn c370_l388_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c370_l388_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c370_l388_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c370_l388_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 389 fn c371_l389_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c371_l389_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c371_l389_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c371_l389_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 390 fn c372_l390_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c372_l390_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c372_l390_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c372_l390_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 391 fn c373_l391_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c373_l391_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c373_l391_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c373_l391_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 392 fn c374_l392_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c374_l392_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c374_l392_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c374_l392_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 393 fn c375_l393_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c375_l393_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c375_l393_assert_return_canonical_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c375_l393_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 394 fn c376_l394_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c376_l394_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c376_l394_assert_return_arithmetic_nan" + ); let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c376_l394_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 395 fn c377_l395_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c377_l395_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c377_l395_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c377_l395_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c377_l395_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 396 fn c378_l396_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c378_l396_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c378_l396_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c378_l396_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c378_l396_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 397 fn c379_l397_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c379_l397_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c379_l397_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c379_l397_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c379_l397_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 398 fn c380_l398_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c380_l398_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c380_l398_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c380_l398_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c380_l398_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 399 fn c381_l399_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c381_l399_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c381_l399_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c381_l399_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c381_l399_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 400 fn c382_l400_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c382_l400_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c382_l400_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c382_l400_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c382_l400_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 401 fn c383_l401_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c383_l401_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c383_l401_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c383_l401_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c383_l401_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 402 fn c384_l402_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c384_l402_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c384_l402_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c384_l402_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c384_l402_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 403 fn c385_l403_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c385_l403_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c385_l403_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c385_l403_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c385_l403_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 404 fn c386_l404_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c386_l404_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c386_l404_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c386_l404_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c386_l404_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 405 fn c387_l405_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c387_l405_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c387_l405_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c387_l405_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c387_l405_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 406 fn c388_l406_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c388_l406_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c388_l406_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c388_l406_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c388_l406_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 407 fn c389_l407_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c389_l407_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c389_l407_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c389_l407_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c389_l407_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 408 fn c390_l408_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c390_l408_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c390_l408_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c390_l408_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c390_l408_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 409 fn c391_l409_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c391_l409_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c391_l409_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c391_l409_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c391_l409_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 410 fn c392_l410_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c392_l410_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c392_l410_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c392_l410_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c392_l410_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 411 fn c393_l411_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c393_l411_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c393_l411_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c393_l411_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c393_l411_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 412 fn c394_l412_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c394_l412_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c394_l412_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c394_l412_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c394_l412_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 413 fn c395_l413_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c395_l413_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c395_l413_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c395_l413_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c395_l413_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 414 fn c396_l414_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c396_l414_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c396_l414_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c396_l414_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c396_l414_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 415 fn c397_l415_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c397_l415_assert_return_canonical_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c397_l415_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c397_l415_assert_return_canonical_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c397_l415_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 416 fn c398_l416_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c398_l416_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c398_l416_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c398_l416_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c398_l416_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 417 fn c399_l417_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c399_l417_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c399_l417_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c399_l417_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c399_l417_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 418 fn c400_l418_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c400_l418_assert_return_arithmetic_nan"); - let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c400_l418_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c400_l418_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "add", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c400_l418_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -3885,7 +5384,10 @@ fn c420_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 439 fn c421_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c421_l439_action_invoke"); - let result = instance.call("sub", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "sub", + &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -3893,7 +5395,10 @@ fn c421_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 440 fn c422_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c422_l440_action_invoke"); - let result = instance.call("sub", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "sub", + &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -3901,7 +5406,10 @@ fn c422_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 441 fn c423_l441_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c423_l441_action_invoke"); - let result = instance.call("sub", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "sub", + &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -3909,7 +5417,10 @@ fn c423_l441_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 442 fn c424_l442_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c424_l442_action_invoke"); - let result = instance.call("sub", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "sub", + &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -3949,7 +5460,10 @@ fn c428_l446_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 447 fn c429_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c429_l447_action_invoke"); - let result = instance.call("sub", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -3965,7 +5479,10 @@ fn c430_l448_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 449 fn c431_l449_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c431_l449_action_invoke"); - let result = instance.call("sub", &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -3980,89 +5497,185 @@ fn c432_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 451 fn c433_l451_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c433_l451_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c433_l451_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c433_l451_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c433_l451_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 452 fn c434_l452_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c434_l452_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c434_l452_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c434_l452_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c434_l452_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 453 fn c435_l453_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c435_l453_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c435_l453_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c435_l453_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c435_l453_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 454 fn c436_l454_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c436_l454_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c436_l454_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c436_l454_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c436_l454_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 455 fn c437_l455_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c437_l455_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c437_l455_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c437_l455_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c437_l455_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 456 fn c438_l456_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c438_l456_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c438_l456_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c438_l456_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c438_l456_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 457 fn c439_l457_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c439_l457_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c439_l457_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c439_l457_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c439_l457_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 458 fn c440_l458_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c440_l458_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c440_l458_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c440_l458_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c440_l458_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -4324,89 +5937,113 @@ fn c472_l490_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 491 fn c473_l491_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c473_l491_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c473_l491_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c473_l491_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 492 fn c474_l492_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c474_l492_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c474_l492_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c474_l492_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 493 fn c475_l493_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c475_l493_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c475_l493_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c475_l493_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 494 fn c476_l494_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c476_l494_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c476_l494_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c476_l494_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 495 fn c477_l495_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c477_l495_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c477_l495_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c477_l495_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 496 fn c478_l496_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c478_l496_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c478_l496_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c478_l496_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 497 fn c479_l497_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c479_l497_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c479_l497_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c479_l497_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 498 fn c480_l498_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c480_l498_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c480_l498_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c480_l498_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -4668,89 +6305,113 @@ fn c512_l530_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 531 fn c513_l531_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c513_l531_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c513_l531_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c513_l531_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 532 fn c514_l532_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c514_l532_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c514_l532_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c514_l532_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 533 fn c515_l533_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c515_l533_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c515_l533_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c515_l533_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 534 fn c516_l534_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c516_l534_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c516_l534_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c516_l534_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 535 fn c517_l535_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c517_l535_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c517_l535_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c517_l535_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 536 fn c518_l536_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c518_l536_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c518_l536_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c518_l536_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 537 fn c519_l537_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c519_l537_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c519_l537_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c519_l537_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 538 fn c520_l538_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c520_l538_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c520_l538_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c520_l538_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -4917,7 +6578,10 @@ fn c540_l558_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 559 fn c541_l559_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c541_l559_action_invoke"); - let result = instance.call("sub", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "sub", + &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((5.783185307179586f64))))); result.map(|_| ()) } @@ -4925,7 +6589,10 @@ fn c541_l559_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 560 fn c542_l560_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c542_l560_action_invoke"); - let result = instance.call("sub", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "sub", + &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.783185307179586f64))))); result.map(|_| ()) } @@ -4933,7 +6600,10 @@ fn c542_l560_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 561 fn c543_l561_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c543_l561_action_invoke"); - let result = instance.call("sub", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "sub", + &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.783185307179586f64))))); result.map(|_| ()) } @@ -4941,7 +6611,10 @@ fn c543_l561_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 562 fn c544_l562_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c544_l562_action_invoke"); - let result = instance.call("sub", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "sub", + &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-5.783185307179586f64))))); result.map(|_| ()) } @@ -4981,7 +6654,10 @@ fn c548_l566_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 567 fn c549_l567_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c549_l567_action_invoke"); - let result = instance.call("sub", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -4997,7 +6673,10 @@ fn c550_l568_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 569 fn c551_l569_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c551_l569_action_invoke"); - let result = instance.call("sub", &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -5012,89 +6691,185 @@ fn c552_l570_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 571 fn c553_l571_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c553_l571_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c553_l571_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c553_l571_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c553_l571_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 572 fn c554_l572_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c554_l572_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c554_l572_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c554_l572_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c554_l572_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 573 fn c555_l573_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c555_l573_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c555_l573_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c555_l573_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c555_l573_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 574 fn c556_l574_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c556_l574_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c556_l574_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c556_l574_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c556_l574_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 575 fn c557_l575_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c557_l575_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c557_l575_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c557_l575_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c557_l575_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 576 fn c558_l576_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c558_l576_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c558_l576_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c558_l576_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c558_l576_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 577 fn c559_l577_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c559_l577_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c559_l577_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c559_l577_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c559_l577_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 578 fn c560_l578_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c560_l578_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c560_l578_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c560_l578_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c560_l578_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -5261,7 +7036,10 @@ fn c580_l598_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 599 fn c581_l599_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c581_l599_action_invoke"); - let result = instance.call("sub", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "sub", + &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((5.283185307179586f64))))); result.map(|_| ()) } @@ -5269,7 +7047,10 @@ fn c581_l599_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 600 fn c582_l600_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c582_l600_action_invoke"); - let result = instance.call("sub", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "sub", + &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-7.283185307179586f64))))); result.map(|_| ()) } @@ -5277,7 +7058,10 @@ fn c582_l600_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 601 fn c583_l601_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c583_l601_action_invoke"); - let result = instance.call("sub", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "sub", + &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((7.283185307179586f64))))); result.map(|_| ()) } @@ -5285,7 +7069,10 @@ fn c583_l601_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 602 fn c584_l602_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c584_l602_action_invoke"); - let result = instance.call("sub", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "sub", + &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-5.283185307179586f64))))); result.map(|_| ()) } @@ -5325,7 +7112,10 @@ fn c588_l606_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 607 fn c589_l607_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c589_l607_action_invoke"); - let result = instance.call("sub", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -5341,7 +7131,10 @@ fn c590_l608_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 609 fn c591_l609_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c591_l609_action_invoke"); - let result = instance.call("sub", &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -5356,96 +7149,195 @@ fn c592_l610_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 611 fn c593_l611_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c593_l611_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c593_l611_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c593_l611_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c593_l611_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 612 fn c594_l612_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c594_l612_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c594_l612_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c594_l612_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c594_l612_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 613 fn c595_l613_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c595_l613_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c595_l613_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c595_l613_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c595_l613_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 614 fn c596_l614_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c596_l614_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c596_l614_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c596_l614_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c596_l614_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 615 fn c597_l615_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c597_l615_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c597_l615_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c597_l615_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c597_l615_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 616 fn c598_l616_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c598_l616_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c598_l616_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c598_l616_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c598_l616_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 617 fn c599_l617_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c599_l617_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c599_l617_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c599_l617_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c599_l617_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 618 fn c600_l618_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c600_l618_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c600_l618_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c600_l618_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c600_l618_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 619 fn c601_l619_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c601_l619_action_invoke"); - let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "sub", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -5453,7 +7345,10 @@ fn c601_l619_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 620 fn c602_l620_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c602_l620_action_invoke"); - let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "sub", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -5461,7 +7356,10 @@ fn c602_l620_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 621 fn c603_l621_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c603_l621_action_invoke"); - let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "sub", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -5469,7 +7367,10 @@ fn c603_l621_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 622 fn c604_l622_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c604_l622_action_invoke"); - let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "sub", + &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -5541,7 +7442,10 @@ fn c612_l630_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 631 fn c613_l631_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c613_l631_action_invoke"); - let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "sub", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-5.783185307179586f64))))); result.map(|_| ()) } @@ -5549,7 +7453,10 @@ fn c613_l631_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 632 fn c614_l632_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c614_l632_action_invoke"); - let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "sub", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.783185307179586f64))))); result.map(|_| ()) } @@ -5557,7 +7464,10 @@ fn c614_l632_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 633 fn c615_l633_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c615_l633_action_invoke"); - let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "sub", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.783185307179586f64))))); result.map(|_| ()) } @@ -5565,7 +7475,10 @@ fn c615_l633_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 634 fn c616_l634_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c616_l634_action_invoke"); - let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "sub", + &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((5.783185307179586f64))))); result.map(|_| ()) } @@ -5573,7 +7486,10 @@ fn c616_l634_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 635 fn c617_l635_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c617_l635_action_invoke"); - let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "sub", + &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-5.283185307179586f64))))); result.map(|_| ()) } @@ -5581,7 +7497,10 @@ fn c617_l635_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 636 fn c618_l636_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c618_l636_action_invoke"); - let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "sub", + &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-7.283185307179586f64))))); result.map(|_| ()) } @@ -5589,7 +7508,10 @@ fn c618_l636_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 637 fn c619_l637_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c619_l637_action_invoke"); - let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "sub", + &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((7.283185307179586f64))))); result.map(|_| ()) } @@ -5597,7 +7519,10 @@ fn c619_l637_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 638 fn c620_l638_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c620_l638_action_invoke"); - let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "sub", + &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((5.283185307179586f64))))); result.map(|_| ()) } @@ -5605,7 +7530,13 @@ fn c620_l638_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 639 fn c621_l639_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c621_l639_action_invoke"); - let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "sub", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5613,7 +7544,13 @@ fn c621_l639_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 640 fn c622_l640_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c622_l640_action_invoke"); - let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "sub", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-12.566370614359172f64))))); result.map(|_| ()) } @@ -5621,7 +7558,13 @@ fn c622_l640_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 641 fn c623_l641_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c623_l641_action_invoke"); - let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "sub", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((12.566370614359172f64))))); result.map(|_| ()) } @@ -5629,7 +7572,13 @@ fn c623_l641_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 642 fn c624_l642_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c624_l642_action_invoke"); - let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "sub", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5669,7 +7618,13 @@ fn c628_l646_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 647 fn c629_l647_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c629_l647_action_invoke"); - let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -5677,7 +7632,13 @@ fn c629_l647_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 648 fn c630_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c630_l648_action_invoke"); - let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -5685,7 +7646,13 @@ fn c630_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 649 fn c631_l649_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c631_l649_action_invoke"); - let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -5693,96 +7660,198 @@ fn c631_l649_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 650 fn c632_l650_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c632_l650_action_invoke"); - let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "sub", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } // Line 651 fn c633_l651_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c633_l651_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c633_l651_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c633_l651_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c633_l651_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 652 fn c634_l652_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c634_l652_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c634_l652_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c634_l652_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c634_l652_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 653 fn c635_l653_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c635_l653_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c635_l653_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c635_l653_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c635_l653_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 654 fn c636_l654_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c636_l654_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c636_l654_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c636_l654_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c636_l654_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 655 fn c637_l655_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c637_l655_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c637_l655_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c637_l655_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c637_l655_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 656 fn c638_l656_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c638_l656_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c638_l656_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c638_l656_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c638_l656_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 657 fn c639_l657_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c639_l657_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c639_l657_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c639_l657_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c639_l657_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 658 fn c640_l658_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c640_l658_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c640_l658_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c640_l658_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c640_l658_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -6044,96 +8113,123 @@ fn c672_l690_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 691 fn c673_l691_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c673_l691_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c673_l691_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c673_l691_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 692 fn c674_l692_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c674_l692_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c674_l692_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c674_l692_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 693 fn c675_l693_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c675_l693_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c675_l693_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c675_l693_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 694 fn c676_l694_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c676_l694_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c676_l694_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c676_l694_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 695 fn c677_l695_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c677_l695_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c677_l695_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c677_l695_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 696 fn c678_l696_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c678_l696_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c678_l696_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c678_l696_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 697 fn c679_l697_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c679_l697_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c679_l697_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c679_l697_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 698 fn c680_l698_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c680_l698_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c680_l698_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c680_l698_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 699 fn c681_l699_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c681_l699_action_invoke"); - let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]); + let result = instance.call( + "sub", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -6141,7 +8237,10 @@ fn c681_l699_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 700 fn c682_l700_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c682_l700_action_invoke"); - let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))]); + let result = instance.call( + "sub", + &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -6229,7 +8328,10 @@ fn c692_l710_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 711 fn c693_l711_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c693_l711_action_invoke"); - let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]); + let result = instance.call( + "sub", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -6237,7 +8339,10 @@ fn c693_l711_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 712 fn c694_l712_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c694_l712_action_invoke"); - let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))]); + let result = instance.call( + "sub", + &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -6261,7 +8366,10 @@ fn c696_l714_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 715 fn c697_l715_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c697_l715_action_invoke"); - let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]); + let result = instance.call( + "sub", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -6269,7 +8377,10 @@ fn c697_l715_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 716 fn c698_l716_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c698_l716_action_invoke"); - let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))]); + let result = instance.call( + "sub", + &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -6293,7 +8404,13 @@ fn c700_l718_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 719 fn c701_l719_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c701_l719_action_invoke"); - let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "sub", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -6301,7 +8418,13 @@ fn c701_l719_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 720 fn c702_l720_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c702_l720_action_invoke"); - let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "sub", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -6309,7 +8432,13 @@ fn c702_l720_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 721 fn c703_l721_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c703_l721_action_invoke"); - let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "sub", + &[ + Value::F64(f64::INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -6317,7 +8446,13 @@ fn c703_l721_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 722 fn c704_l722_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c704_l722_action_invoke"); - let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "sub", + &[ + Value::F64(f64::INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -6356,19 +8491,31 @@ fn c708_l726_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 727 fn c709_l727_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c709_l727_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c709_l727_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c709_l727_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)], + ) + .unwrap() + .expect("Missing result in c709_l727_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 728 fn c710_l728_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c710_l728_action_invoke"); - let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "sub", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -6376,987 +8523,1839 @@ fn c710_l728_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 729 fn c711_l729_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c711_l729_action_invoke"); - let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "sub", + &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } // Line 730 fn c712_l730_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c712_l730_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c712_l730_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c712_l730_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)], + ) + .unwrap() + .expect("Missing result in c712_l730_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 731 fn c713_l731_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c713_l731_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c713_l731_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c713_l731_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c713_l731_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 732 fn c714_l732_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c714_l732_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c714_l732_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c714_l732_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c714_l732_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 733 fn c715_l733_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c715_l733_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c715_l733_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c715_l733_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c715_l733_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 734 fn c716_l734_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c716_l734_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c716_l734_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c716_l734_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c716_l734_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 735 fn c717_l735_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c717_l735_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c717_l735_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c717_l735_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c717_l735_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 736 fn c718_l736_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c718_l736_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c718_l736_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c718_l736_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c718_l736_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 737 fn c719_l737_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c719_l737_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c719_l737_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c719_l737_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c719_l737_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 738 fn c720_l738_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c720_l738_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c720_l738_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c720_l738_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c720_l738_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 739 fn c721_l739_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c721_l739_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c721_l739_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c721_l739_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c721_l739_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 740 fn c722_l740_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c722_l740_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c722_l740_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c722_l740_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c722_l740_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 741 fn c723_l741_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c723_l741_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c723_l741_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c723_l741_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c723_l741_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 742 fn c724_l742_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c724_l742_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c724_l742_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c724_l742_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c724_l742_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 743 fn c725_l743_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c725_l743_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c725_l743_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c725_l743_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c725_l743_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 744 fn c726_l744_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c726_l744_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c726_l744_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c726_l744_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c726_l744_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 745 fn c727_l745_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c727_l745_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c727_l745_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c727_l745_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c727_l745_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 746 fn c728_l746_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c728_l746_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c728_l746_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c728_l746_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c728_l746_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 747 fn c729_l747_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c729_l747_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c729_l747_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c729_l747_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 748 fn c730_l748_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c730_l748_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c730_l748_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c730_l748_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 749 fn c731_l749_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c731_l749_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c731_l749_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c731_l749_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 750 fn c732_l750_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c732_l750_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c732_l750_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c732_l750_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 751 fn c733_l751_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c733_l751_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c733_l751_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c733_l751_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 752 fn c734_l752_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c734_l752_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c734_l752_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c734_l752_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 753 fn c735_l753_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c735_l753_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c735_l753_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c735_l753_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 754 fn c736_l754_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c736_l754_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c736_l754_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c736_l754_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 755 fn c737_l755_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c737_l755_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c737_l755_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c737_l755_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 756 fn c738_l756_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c738_l756_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c738_l756_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c738_l756_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 757 fn c739_l757_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c739_l757_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c739_l757_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c739_l757_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 758 fn c740_l758_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c740_l758_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c740_l758_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c740_l758_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 759 fn c741_l759_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c741_l759_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c741_l759_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c741_l759_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 760 fn c742_l760_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c742_l760_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c742_l760_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c742_l760_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 761 fn c743_l761_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c743_l761_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c743_l761_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c743_l761_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 762 fn c744_l762_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c744_l762_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c744_l762_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c744_l762_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 763 fn c745_l763_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c745_l763_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c745_l763_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c745_l763_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c745_l763_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 764 fn c746_l764_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c746_l764_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c746_l764_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c746_l764_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c746_l764_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 765 fn c747_l765_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c747_l765_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c747_l765_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c747_l765_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c747_l765_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 766 fn c748_l766_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c748_l766_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c748_l766_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c748_l766_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c748_l766_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 767 fn c749_l767_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c749_l767_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c749_l767_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c749_l767_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c749_l767_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 768 fn c750_l768_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c750_l768_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c750_l768_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c750_l768_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c750_l768_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 769 fn c751_l769_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c751_l769_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c751_l769_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c751_l769_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c751_l769_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 770 fn c752_l770_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c752_l770_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c752_l770_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c752_l770_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c752_l770_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 771 fn c753_l771_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c753_l771_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c753_l771_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c753_l771_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c753_l771_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 772 fn c754_l772_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c754_l772_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c754_l772_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c754_l772_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c754_l772_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 773 fn c755_l773_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c755_l773_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c755_l773_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c755_l773_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c755_l773_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 774 fn c756_l774_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c756_l774_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c756_l774_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c756_l774_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c756_l774_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 775 fn c757_l775_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c757_l775_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c757_l775_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c757_l775_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c757_l775_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 776 fn c758_l776_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c758_l776_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c758_l776_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c758_l776_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c758_l776_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 777 fn c759_l777_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c759_l777_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c759_l777_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c759_l777_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c759_l777_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 778 fn c760_l778_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c760_l778_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c760_l778_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c760_l778_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c760_l778_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 779 fn c761_l779_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c761_l779_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c761_l779_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c761_l779_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c761_l779_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 780 fn c762_l780_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c762_l780_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c762_l780_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c762_l780_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c762_l780_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 781 fn c763_l781_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c763_l781_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c763_l781_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c763_l781_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c763_l781_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 782 fn c764_l782_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c764_l782_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c764_l782_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c764_l782_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c764_l782_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 783 fn c765_l783_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c765_l783_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c765_l783_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c765_l783_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c765_l783_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 784 fn c766_l784_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c766_l784_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c766_l784_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c766_l784_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c766_l784_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 785 fn c767_l785_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c767_l785_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c767_l785_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c767_l785_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c767_l785_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 786 fn c768_l786_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c768_l786_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c768_l786_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c768_l786_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c768_l786_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 787 fn c769_l787_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c769_l787_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c769_l787_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c769_l787_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 788 fn c770_l788_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c770_l788_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c770_l788_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c770_l788_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 789 fn c771_l789_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c771_l789_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c771_l789_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c771_l789_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 790 fn c772_l790_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c772_l790_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c772_l790_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c772_l790_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 791 fn c773_l791_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c773_l791_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c773_l791_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c773_l791_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 792 fn c774_l792_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c774_l792_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c774_l792_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c774_l792_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 793 fn c775_l793_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c775_l793_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c775_l793_assert_return_canonical_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c775_l793_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 794 fn c776_l794_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c776_l794_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c776_l794_assert_return_arithmetic_nan" + ); let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c776_l794_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 795 fn c777_l795_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c777_l795_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c777_l795_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c777_l795_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c777_l795_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 796 fn c778_l796_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c778_l796_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c778_l796_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c778_l796_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c778_l796_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 797 fn c779_l797_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c779_l797_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c779_l797_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c779_l797_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c779_l797_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 798 fn c780_l798_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c780_l798_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c780_l798_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c780_l798_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c780_l798_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 799 fn c781_l799_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c781_l799_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c781_l799_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c781_l799_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c781_l799_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 800 fn c782_l800_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c782_l800_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c782_l800_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c782_l800_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c782_l800_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 801 fn c783_l801_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c783_l801_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c783_l801_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c783_l801_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c783_l801_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 802 fn c784_l802_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c784_l802_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c784_l802_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c784_l802_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c784_l802_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 803 fn c785_l803_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c785_l803_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c785_l803_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c785_l803_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c785_l803_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 804 fn c786_l804_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c786_l804_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c786_l804_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c786_l804_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c786_l804_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 805 fn c787_l805_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c787_l805_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c787_l805_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c787_l805_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c787_l805_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 806 fn c788_l806_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c788_l806_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c788_l806_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c788_l806_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c788_l806_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 807 fn c789_l807_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c789_l807_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c789_l807_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c789_l807_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c789_l807_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 808 fn c790_l808_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c790_l808_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c790_l808_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c790_l808_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c790_l808_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 809 fn c791_l809_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c791_l809_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c791_l809_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c791_l809_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c791_l809_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 810 fn c792_l810_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c792_l810_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c792_l810_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c792_l810_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c792_l810_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 811 fn c793_l811_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c793_l811_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c793_l811_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c793_l811_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c793_l811_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 812 fn c794_l812_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c794_l812_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c794_l812_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c794_l812_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c794_l812_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 813 fn c795_l813_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c795_l813_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c795_l813_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c795_l813_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c795_l813_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 814 fn c796_l814_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c796_l814_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c796_l814_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c796_l814_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c796_l814_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 815 fn c797_l815_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c797_l815_assert_return_canonical_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c797_l815_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c797_l815_assert_return_canonical_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c797_l815_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 816 fn c798_l816_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c798_l816_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c798_l816_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c798_l816_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c798_l816_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 817 fn c799_l817_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c799_l817_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c799_l817_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c799_l817_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c799_l817_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 818 fn c800_l818_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c800_l818_assert_return_arithmetic_nan"); - let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c800_l818_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c800_l818_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "sub", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c800_l818_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -7523,7 +10522,10 @@ fn c820_l838_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 839 fn c821_l839_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c821_l839_action_invoke"); - let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "mul", + &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -7531,7 +10533,10 @@ fn c821_l839_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 840 fn c822_l840_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c822_l840_action_invoke"); - let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "mul", + &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -7539,7 +10544,10 @@ fn c822_l840_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 841 fn c823_l841_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c823_l841_action_invoke"); - let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "mul", + &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -7547,7 +10555,10 @@ fn c823_l841_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 842 fn c824_l842_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c824_l842_action_invoke"); - let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "mul", + &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -7586,133 +10597,259 @@ fn c828_l846_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 847 fn c829_l847_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c829_l847_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c829_l847_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c829_l847_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)], + ) + .unwrap() + .expect("Missing result in c829_l847_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 848 fn c830_l848_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c830_l848_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c830_l848_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c830_l848_assert_return_canonical_nan" + ); + let result = instance + .call("mul", &[Value::F64((-0.0f64)), Value::F64(f64::INFINITY)]) + .unwrap() + .expect("Missing result in c830_l848_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 849 fn c831_l849_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c831_l849_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c831_l849_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c831_l849_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)], + ) + .unwrap() + .expect("Missing result in c831_l849_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 850 fn c832_l850_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c832_l850_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c832_l850_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c832_l850_assert_return_canonical_nan" + ); + let result = instance + .call("mul", &[Value::F64((0.0f64)), Value::F64(f64::INFINITY)]) + .unwrap() + .expect("Missing result in c832_l850_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 851 fn c833_l851_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c833_l851_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c833_l851_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c833_l851_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c833_l851_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 852 fn c834_l852_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c834_l852_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c834_l852_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c834_l852_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c834_l852_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 853 fn c835_l853_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c835_l853_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c835_l853_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c835_l853_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c835_l853_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 854 fn c836_l854_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c836_l854_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c836_l854_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c836_l854_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c836_l854_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 855 fn c837_l855_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c837_l855_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c837_l855_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c837_l855_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c837_l855_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 856 fn c838_l856_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c838_l856_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c838_l856_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c838_l856_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c838_l856_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 857 fn c839_l857_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c839_l857_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c839_l857_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c839_l857_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c839_l857_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 858 fn c840_l858_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c840_l858_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c840_l858_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c840_l858_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c840_l858_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -7912,7 +11049,10 @@ fn c864_l882_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c865_l883_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c865_l883_action_invoke"); let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.0000000000000008881784197001251f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((0.0000000000000008881784197001251f64)))) + ); result.map(|_| ()) } @@ -7920,7 +11060,10 @@ fn c865_l883_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c866_l884_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c866_l884_action_invoke"); let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000008881784197001251f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((-0.0000000000000008881784197001251f64)))) + ); result.map(|_| ()) } @@ -7928,7 +11071,10 @@ fn c866_l884_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c867_l885_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c867_l885_action_invoke"); let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000008881784197001251f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((-0.0000000000000008881784197001251f64)))) + ); result.map(|_| ()) } @@ -7936,7 +11082,10 @@ fn c867_l885_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c868_l886_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c868_l886_action_invoke"); let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.0000000000000008881784197001251f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((0.0000000000000008881784197001251f64)))) + ); result.map(|_| ()) } @@ -7974,89 +11123,113 @@ fn c872_l890_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 891 fn c873_l891_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c873_l891_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c873_l891_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c873_l891_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 892 fn c874_l892_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c874_l892_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c874_l892_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c874_l892_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 893 fn c875_l893_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c875_l893_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c875_l893_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c875_l893_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 894 fn c876_l894_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c876_l894_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c876_l894_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c876_l894_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 895 fn c877_l895_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c877_l895_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c877_l895_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c877_l895_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 896 fn c878_l896_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c878_l896_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c878_l896_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c878_l896_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 897 fn c879_l897_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c879_l897_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c879_l897_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c879_l897_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 898 fn c880_l898_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c880_l898_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c880_l898_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c880_l898_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -8318,89 +11491,113 @@ fn c912_l930_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 931 fn c913_l931_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c913_l931_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c913_l931_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c913_l931_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 932 fn c914_l932_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c914_l932_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c914_l932_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c914_l932_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 933 fn c915_l933_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c915_l933_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c915_l933_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c915_l933_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 934 fn c916_l934_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c916_l934_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c916_l934_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c916_l934_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 935 fn c917_l935_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c917_l935_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c917_l935_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c917_l935_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 936 fn c918_l936_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c918_l936_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c918_l936_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c918_l936_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 937 fn c919_l937_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c919_l937_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c919_l937_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c919_l937_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 938 fn c920_l938_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c920_l938_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c920_l938_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c920_l938_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -8567,7 +11764,10 @@ fn c940_l958_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 959 fn c941_l959_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c941_l959_action_invoke"); - let result = instance.call("mul", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "mul", + &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((3.141592653589793f64))))); result.map(|_| ()) } @@ -8575,7 +11775,10 @@ fn c941_l959_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 960 fn c942_l960_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c942_l960_action_invoke"); - let result = instance.call("mul", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "mul", + &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-3.141592653589793f64))))); result.map(|_| ()) } @@ -8583,7 +11786,10 @@ fn c942_l960_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 961 fn c943_l961_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c943_l961_action_invoke"); - let result = instance.call("mul", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "mul", + &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-3.141592653589793f64))))); result.map(|_| ()) } @@ -8591,7 +11797,10 @@ fn c943_l961_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 962 fn c944_l962_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c944_l962_action_invoke"); - let result = instance.call("mul", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "mul", + &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((3.141592653589793f64))))); result.map(|_| ()) } @@ -8631,7 +11840,10 @@ fn c948_l966_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 967 fn c949_l967_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c949_l967_action_invoke"); - let result = instance.call("mul", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -8647,7 +11859,10 @@ fn c950_l968_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 969 fn c951_l969_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c951_l969_action_invoke"); - let result = instance.call("mul", &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -8662,89 +11877,185 @@ fn c952_l970_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 971 fn c953_l971_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c953_l971_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c953_l971_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c953_l971_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c953_l971_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 972 fn c954_l972_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c954_l972_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c954_l972_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c954_l972_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c954_l972_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 973 fn c955_l973_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c955_l973_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c955_l973_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c955_l973_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c955_l973_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 974 fn c956_l974_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c956_l974_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c956_l974_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c956_l974_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c956_l974_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 975 fn c957_l975_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c957_l975_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c957_l975_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c957_l975_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c957_l975_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 976 fn c958_l976_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c958_l976_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c958_l976_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c958_l976_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c958_l976_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 977 fn c959_l977_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c959_l977_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c959_l977_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c959_l977_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c959_l977_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 978 fn c960_l978_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c960_l978_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c960_l978_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c960_l978_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c960_l978_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -8911,7 +12222,10 @@ fn c980_l998_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 999 fn c981_l999_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c981_l999_action_invoke"); - let result = instance.call("mul", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "mul", + &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -8919,7 +12233,10 @@ fn c981_l999_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1000 fn c982_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c982_l1000_action_invoke"); - let result = instance.call("mul", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "mul", + &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -8927,7 +12244,10 @@ fn c982_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1001 fn c983_l1001_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c983_l1001_action_invoke"); - let result = instance.call("mul", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "mul", + &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -8935,7 +12255,10 @@ fn c983_l1001_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1002 fn c984_l1002_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c984_l1002_action_invoke"); - let result = instance.call("mul", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "mul", + &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -8975,7 +12298,10 @@ fn c988_l1006_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1007 fn c989_l1007_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c989_l1007_action_invoke"); - let result = instance.call("mul", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -8991,7 +12317,10 @@ fn c990_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1009 fn c991_l1009_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c991_l1009_action_invoke"); - let result = instance.call("mul", &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -9006,96 +12335,195 @@ fn c992_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1011 fn c993_l1011_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c993_l1011_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c993_l1011_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c993_l1011_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c993_l1011_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1012 fn c994_l1012_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c994_l1012_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c994_l1012_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c994_l1012_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c994_l1012_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1013 fn c995_l1013_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c995_l1013_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c995_l1013_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c995_l1013_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c995_l1013_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1014 fn c996_l1014_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c996_l1014_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c996_l1014_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c996_l1014_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c996_l1014_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1015 fn c997_l1015_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c997_l1015_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c997_l1015_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c997_l1015_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c997_l1015_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1016 fn c998_l1016_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c998_l1016_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c998_l1016_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c998_l1016_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c998_l1016_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1017 fn c999_l1017_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c999_l1017_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c999_l1017_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c999_l1017_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c999_l1017_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1018 fn c1000_l1018_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1000_l1018_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1000_l1018_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1000_l1018_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1000_l1018_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1019 fn c1001_l1019_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1001_l1019_action_invoke"); - let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "mul", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -9103,7 +12531,10 @@ fn c1001_l1019_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1020 fn c1002_l1020_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1002_l1020_action_invoke"); - let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "mul", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -9111,7 +12542,10 @@ fn c1002_l1020_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1021 fn c1003_l1021_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1003_l1021_action_invoke"); - let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "mul", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -9119,7 +12553,10 @@ fn c1003_l1021_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1022 fn c1004_l1022_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1004_l1022_action_invoke"); - let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "mul", + &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -9191,7 +12628,10 @@ fn c1012_l1030_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1031 fn c1013_l1031_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1013_l1031_action_invoke"); - let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "mul", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((3.141592653589793f64))))); result.map(|_| ()) } @@ -9199,7 +12639,10 @@ fn c1013_l1031_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1032 fn c1014_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1014_l1032_action_invoke"); - let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "mul", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-3.141592653589793f64))))); result.map(|_| ()) } @@ -9207,7 +12650,10 @@ fn c1014_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1033 fn c1015_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1015_l1033_action_invoke"); - let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "mul", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-3.141592653589793f64))))); result.map(|_| ()) } @@ -9215,7 +12661,10 @@ fn c1015_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1034 fn c1016_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1016_l1034_action_invoke"); - let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "mul", + &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((3.141592653589793f64))))); result.map(|_| ()) } @@ -9223,7 +12672,10 @@ fn c1016_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1035 fn c1017_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1017_l1035_action_invoke"); - let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "mul", + &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -9231,7 +12683,10 @@ fn c1017_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1036 fn c1018_l1036_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1018_l1036_action_invoke"); - let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "mul", + &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -9239,7 +12694,10 @@ fn c1018_l1036_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1037 fn c1019_l1037_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1019_l1037_action_invoke"); - let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "mul", + &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -9247,7 +12705,10 @@ fn c1019_l1037_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1038 fn c1020_l1038_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1020_l1038_action_invoke"); - let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "mul", + &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -9255,7 +12716,13 @@ fn c1020_l1038_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1039 fn c1021_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1021_l1039_action_invoke"); - let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "mul", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((39.47841760435743f64))))); result.map(|_| ()) } @@ -9263,7 +12730,13 @@ fn c1021_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1040 fn c1022_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1022_l1040_action_invoke"); - let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "mul", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-39.47841760435743f64))))); result.map(|_| ()) } @@ -9271,7 +12744,13 @@ fn c1022_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1041 fn c1023_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1023_l1041_action_invoke"); - let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "mul", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-39.47841760435743f64))))); result.map(|_| ()) } @@ -9279,7 +12758,13 @@ fn c1023_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1042 fn c1024_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1024_l1042_action_invoke"); - let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "mul", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((39.47841760435743f64))))); result.map(|_| ()) } @@ -9319,7 +12804,13 @@ fn c1028_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1047 fn c1029_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1029_l1047_action_invoke"); - let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -9327,7 +12818,13 @@ fn c1029_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1048 fn c1030_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1030_l1048_action_invoke"); - let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -9335,7 +12832,13 @@ fn c1030_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1049 fn c1031_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1031_l1049_action_invoke"); - let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -9343,96 +12846,198 @@ fn c1031_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1050 fn c1032_l1050_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1032_l1050_action_invoke"); - let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "mul", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } // Line 1051 fn c1033_l1051_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1033_l1051_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1033_l1051_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1033_l1051_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1033_l1051_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1052 fn c1034_l1052_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1034_l1052_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1034_l1052_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1034_l1052_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1034_l1052_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1053 fn c1035_l1053_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1035_l1053_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1035_l1053_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1035_l1053_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1035_l1053_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1054 fn c1036_l1054_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1036_l1054_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1036_l1054_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1036_l1054_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1036_l1054_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1055 fn c1037_l1055_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1037_l1055_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1037_l1055_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1037_l1055_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1037_l1055_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1056 fn c1038_l1056_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1038_l1056_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1038_l1056_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1038_l1056_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1038_l1056_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1057 fn c1039_l1057_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1039_l1057_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1039_l1057_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1039_l1057_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1039_l1057_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1058 fn c1040_l1058_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1040_l1058_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1040_l1058_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1040_l1058_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1040_l1058_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -9472,7 +13077,10 @@ fn c1044_l1062_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c1045_l1063_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1045_l1063_action_invoke"); let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.0000000000000008881784197001251f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((0.0000000000000008881784197001251f64)))) + ); result.map(|_| ()) } @@ -9480,7 +13088,10 @@ fn c1045_l1063_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c1046_l1064_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1046_l1064_action_invoke"); let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000008881784197001251f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((-0.0000000000000008881784197001251f64)))) + ); result.map(|_| ()) } @@ -9488,7 +13099,10 @@ fn c1046_l1064_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c1047_l1065_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1047_l1065_action_invoke"); let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000008881784197001251f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((-0.0000000000000008881784197001251f64)))) + ); result.map(|_| ()) } @@ -9496,7 +13110,10 @@ fn c1047_l1065_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c1048_l1066_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1048_l1066_action_invoke"); let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.0000000000000008881784197001251f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((0.0000000000000008881784197001251f64)))) + ); result.map(|_| ()) } @@ -9694,133 +13311,187 @@ fn c1072_l1090_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1091 fn c1073_l1091_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1073_l1091_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1073_l1091_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1073_l1091_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1092 fn c1074_l1092_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1074_l1092_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1074_l1092_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1074_l1092_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1093 fn c1075_l1093_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1075_l1093_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1075_l1093_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1075_l1093_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1094 fn c1076_l1094_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1076_l1094_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1076_l1094_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1076_l1094_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1095 fn c1077_l1095_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1077_l1095_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1077_l1095_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1077_l1095_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1096 fn c1078_l1096_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1078_l1096_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1078_l1096_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1078_l1096_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1097 fn c1079_l1097_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1079_l1097_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1079_l1097_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1079_l1097_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1098 fn c1080_l1098_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1080_l1098_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1080_l1098_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1080_l1098_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1099 fn c1081_l1099_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1081_l1099_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1081_l1099_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1081_l1099_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))], + ) + .unwrap() + .expect("Missing result in c1081_l1099_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1100 fn c1082_l1100_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1082_l1100_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1082_l1100_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1082_l1100_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))], + ) + .unwrap() + .expect("Missing result in c1082_l1100_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1101 fn c1083_l1101_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1083_l1101_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1083_l1101_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1083_l1101_assert_return_canonical_nan" + ); + let result = instance + .call("mul", &[Value::F64(f64::INFINITY), Value::F64((-0.0f64))]) + .unwrap() + .expect("Missing result in c1083_l1101_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1102 fn c1084_l1102_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1084_l1102_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1084_l1102_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1084_l1102_assert_return_canonical_nan" + ); + let result = instance + .call("mul", &[Value::F64(f64::INFINITY), Value::F64((0.0f64))]) + .unwrap() + .expect("Missing result in c1084_l1102_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -9891,7 +13562,10 @@ fn c1092_l1110_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1111 fn c1093_l1111_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1093_l1111_action_invoke"); - let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]); + let result = instance.call( + "mul", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -9899,7 +13573,10 @@ fn c1093_l1111_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1112 fn c1094_l1112_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1094_l1112_action_invoke"); - let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))]); + let result = instance.call( + "mul", + &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -9923,7 +13600,10 @@ fn c1096_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1115 fn c1097_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1097_l1115_action_invoke"); - let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]); + let result = instance.call( + "mul", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -9931,7 +13611,10 @@ fn c1097_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1116 fn c1098_l1116_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1098_l1116_action_invoke"); - let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))]); + let result = instance.call( + "mul", + &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -9955,7 +13638,13 @@ fn c1100_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1119 fn c1101_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1101_l1119_action_invoke"); - let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "mul", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -9963,7 +13652,13 @@ fn c1101_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1120 fn c1102_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1102_l1120_action_invoke"); - let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "mul", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -9971,7 +13666,13 @@ fn c1102_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1121 fn c1103_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1103_l1121_action_invoke"); - let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "mul", + &[ + Value::F64(f64::INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -9979,7 +13680,13 @@ fn c1103_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1122 fn c1104_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1104_l1122_action_invoke"); - let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "mul", + &[ + Value::F64(f64::INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -10019,7 +13726,10 @@ fn c1108_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1127 fn c1109_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1109_l1127_action_invoke"); - let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -10027,7 +13737,10 @@ fn c1109_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1128 fn c1110_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1110_l1128_action_invoke"); - let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "mul", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -10035,7 +13748,10 @@ fn c1110_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1129 fn c1111_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1111_l1129_action_invoke"); - let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "mul", + &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -10043,1020 +13759,1887 @@ fn c1111_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1130 fn c1112_l1130_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1112_l1130_action_invoke"); - let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "mul", + &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } // Line 1131 fn c1113_l1131_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1113_l1131_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1113_l1131_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1113_l1131_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1113_l1131_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1132 fn c1114_l1132_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1114_l1132_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1114_l1132_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1114_l1132_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1114_l1132_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1133 fn c1115_l1133_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1115_l1133_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1115_l1133_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1115_l1133_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1115_l1133_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1134 fn c1116_l1134_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1116_l1134_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1116_l1134_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1116_l1134_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1116_l1134_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1135 fn c1117_l1135_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1117_l1135_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1117_l1135_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1117_l1135_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1117_l1135_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1136 fn c1118_l1136_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1118_l1136_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1118_l1136_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1118_l1136_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1118_l1136_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1137 fn c1119_l1137_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1119_l1137_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1119_l1137_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1119_l1137_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1119_l1137_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1138 fn c1120_l1138_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1120_l1138_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1120_l1138_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1120_l1138_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1120_l1138_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1139 fn c1121_l1139_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1121_l1139_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1121_l1139_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1121_l1139_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1121_l1139_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1140 fn c1122_l1140_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1122_l1140_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1122_l1140_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1122_l1140_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1122_l1140_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1141 fn c1123_l1141_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1123_l1141_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1123_l1141_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1123_l1141_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1123_l1141_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1142 fn c1124_l1142_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1124_l1142_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1124_l1142_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1124_l1142_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1124_l1142_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1143 fn c1125_l1143_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1125_l1143_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1125_l1143_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1125_l1143_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1125_l1143_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1144 fn c1126_l1144_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1126_l1144_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1126_l1144_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1126_l1144_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1126_l1144_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1145 fn c1127_l1145_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1127_l1145_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1127_l1145_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1127_l1145_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1127_l1145_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1146 fn c1128_l1146_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1128_l1146_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1128_l1146_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1128_l1146_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1128_l1146_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1147 fn c1129_l1147_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1129_l1147_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1129_l1147_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1129_l1147_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1148 fn c1130_l1148_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1130_l1148_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1130_l1148_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1130_l1148_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1149 fn c1131_l1149_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1131_l1149_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1131_l1149_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1131_l1149_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1150 fn c1132_l1150_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1132_l1150_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1132_l1150_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1132_l1150_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1151 fn c1133_l1151_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1133_l1151_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1133_l1151_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1133_l1151_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1152 fn c1134_l1152_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1134_l1152_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1134_l1152_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1134_l1152_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1153 fn c1135_l1153_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1135_l1153_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1135_l1153_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1135_l1153_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1154 fn c1136_l1154_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1136_l1154_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1136_l1154_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1136_l1154_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1155 fn c1137_l1155_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1137_l1155_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1137_l1155_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1137_l1155_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1156 fn c1138_l1156_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1138_l1156_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1138_l1156_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1138_l1156_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1157 fn c1139_l1157_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1139_l1157_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1139_l1157_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1139_l1157_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1158 fn c1140_l1158_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1140_l1158_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1140_l1158_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1140_l1158_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1159 fn c1141_l1159_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1141_l1159_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1141_l1159_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1141_l1159_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1160 fn c1142_l1160_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1142_l1160_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1142_l1160_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1142_l1160_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1161 fn c1143_l1161_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1143_l1161_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1143_l1161_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1143_l1161_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1162 fn c1144_l1162_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1144_l1162_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1144_l1162_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1144_l1162_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1163 fn c1145_l1163_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1145_l1163_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1145_l1163_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1145_l1163_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1145_l1163_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1164 fn c1146_l1164_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1146_l1164_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1146_l1164_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1146_l1164_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1146_l1164_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1165 fn c1147_l1165_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1147_l1165_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1147_l1165_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1147_l1165_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1147_l1165_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1166 fn c1148_l1166_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1148_l1166_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1148_l1166_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1148_l1166_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1148_l1166_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1167 fn c1149_l1167_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1149_l1167_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1149_l1167_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1149_l1167_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1149_l1167_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1168 fn c1150_l1168_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1150_l1168_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1150_l1168_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1150_l1168_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1150_l1168_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1169 fn c1151_l1169_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1151_l1169_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1151_l1169_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1151_l1169_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1151_l1169_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1170 fn c1152_l1170_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1152_l1170_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1152_l1170_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1152_l1170_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1152_l1170_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1171 fn c1153_l1171_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1153_l1171_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1153_l1171_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1153_l1171_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1153_l1171_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1172 fn c1154_l1172_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1154_l1172_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1154_l1172_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1154_l1172_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1154_l1172_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1173 fn c1155_l1173_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1155_l1173_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1155_l1173_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1155_l1173_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1155_l1173_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1174 fn c1156_l1174_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1156_l1174_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1156_l1174_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1156_l1174_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1156_l1174_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1175 fn c1157_l1175_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1157_l1175_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1157_l1175_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1157_l1175_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1157_l1175_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1176 fn c1158_l1176_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1158_l1176_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1158_l1176_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1158_l1176_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1158_l1176_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1177 fn c1159_l1177_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1159_l1177_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1159_l1177_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1159_l1177_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1159_l1177_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1178 fn c1160_l1178_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1160_l1178_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1160_l1178_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1160_l1178_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1160_l1178_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1179 fn c1161_l1179_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1161_l1179_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1161_l1179_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1161_l1179_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1161_l1179_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1180 fn c1162_l1180_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1162_l1180_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1162_l1180_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1162_l1180_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1162_l1180_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1181 fn c1163_l1181_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1163_l1181_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1163_l1181_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1163_l1181_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1163_l1181_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1182 fn c1164_l1182_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1164_l1182_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1164_l1182_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1164_l1182_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1164_l1182_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1183 fn c1165_l1183_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1165_l1183_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1165_l1183_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1165_l1183_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1165_l1183_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1184 fn c1166_l1184_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1166_l1184_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1166_l1184_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1166_l1184_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1166_l1184_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1185 fn c1167_l1185_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1167_l1185_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1167_l1185_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1167_l1185_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1167_l1185_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1186 fn c1168_l1186_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1168_l1186_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1168_l1186_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1168_l1186_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1168_l1186_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1187 fn c1169_l1187_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1169_l1187_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1169_l1187_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1169_l1187_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1188 fn c1170_l1188_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1170_l1188_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1170_l1188_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1170_l1188_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1189 fn c1171_l1189_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1171_l1189_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1171_l1189_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1171_l1189_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1190 fn c1172_l1190_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1172_l1190_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1172_l1190_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1172_l1190_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1191 fn c1173_l1191_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1173_l1191_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1173_l1191_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1173_l1191_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1192 fn c1174_l1192_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1174_l1192_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1174_l1192_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1174_l1192_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1193 fn c1175_l1193_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1175_l1193_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1175_l1193_assert_return_canonical_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1175_l1193_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1194 fn c1176_l1194_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1176_l1194_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1176_l1194_assert_return_arithmetic_nan" + ); let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1176_l1194_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1195 fn c1177_l1195_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1177_l1195_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1177_l1195_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1177_l1195_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1177_l1195_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1196 fn c1178_l1196_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1178_l1196_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1178_l1196_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1178_l1196_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1178_l1196_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1197 fn c1179_l1197_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1179_l1197_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1179_l1197_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1179_l1197_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1179_l1197_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1198 fn c1180_l1198_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1180_l1198_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1180_l1198_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1180_l1198_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1180_l1198_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1199 fn c1181_l1199_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1181_l1199_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1181_l1199_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1181_l1199_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1181_l1199_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1200 fn c1182_l1200_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1182_l1200_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1182_l1200_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1182_l1200_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1182_l1200_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1201 fn c1183_l1201_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1183_l1201_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1183_l1201_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1183_l1201_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1183_l1201_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1202 fn c1184_l1202_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1184_l1202_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1184_l1202_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1184_l1202_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1184_l1202_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1203 fn c1185_l1203_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1185_l1203_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1185_l1203_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1185_l1203_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1185_l1203_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1204 fn c1186_l1204_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1186_l1204_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1186_l1204_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1186_l1204_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1186_l1204_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1205 fn c1187_l1205_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1187_l1205_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1187_l1205_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1187_l1205_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1187_l1205_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1206 fn c1188_l1206_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1188_l1206_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1188_l1206_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1188_l1206_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1188_l1206_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1207 fn c1189_l1207_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1189_l1207_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1189_l1207_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1189_l1207_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1189_l1207_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1208 fn c1190_l1208_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1190_l1208_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1190_l1208_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1190_l1208_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1190_l1208_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1209 fn c1191_l1209_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1191_l1209_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1191_l1209_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1191_l1209_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1191_l1209_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1210 fn c1192_l1210_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1192_l1210_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1192_l1210_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1192_l1210_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1192_l1210_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1211 fn c1193_l1211_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1193_l1211_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1193_l1211_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1193_l1211_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1193_l1211_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1212 fn c1194_l1212_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1194_l1212_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1194_l1212_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1194_l1212_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1194_l1212_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1213 fn c1195_l1213_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1195_l1213_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1195_l1213_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1195_l1213_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1195_l1213_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1214 fn c1196_l1214_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1196_l1214_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1196_l1214_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1196_l1214_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1196_l1214_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1215 fn c1197_l1215_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1197_l1215_assert_return_canonical_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1197_l1215_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1197_l1215_assert_return_canonical_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1197_l1215_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1216 fn c1198_l1216_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1198_l1216_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1198_l1216_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1198_l1216_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1198_l1216_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1217 fn c1199_l1217_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1199_l1217_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1199_l1217_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1199_l1217_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1199_l1217_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1218 fn c1200_l1218_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1200_l1218_assert_return_arithmetic_nan"); - let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1200_l1218_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1200_l1218_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "mul", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1200_l1218_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1219 fn c1201_l1219_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1201_l1219_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1201_l1219_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1201_l1219_assert_return_canonical_nan" + ); + let result = instance + .call("div", &[Value::F64((-0.0f64)), Value::F64((-0.0f64))]) + .unwrap() + .expect("Missing result in c1201_l1219_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1220 fn c1202_l1220_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1202_l1220_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1202_l1220_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1202_l1220_assert_return_canonical_nan" + ); + let result = instance + .call("div", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]) + .unwrap() + .expect("Missing result in c1202_l1220_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1221 fn c1203_l1221_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1203_l1221_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1203_l1221_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1203_l1221_assert_return_canonical_nan" + ); + let result = instance + .call("div", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]) + .unwrap() + .expect("Missing result in c1203_l1221_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1222 fn c1204_l1222_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1204_l1222_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1204_l1222_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1204_l1222_assert_return_canonical_nan" + ); + let result = instance + .call("div", &[Value::F64((0.0f64)), Value::F64((0.0f64))]) + .unwrap() + .expect("Missing result in c1204_l1222_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -11191,7 +15774,10 @@ fn c1220_l1238_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1239 fn c1221_l1239_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1221_l1239_action_invoke"); - let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "div", + &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -11199,7 +15785,10 @@ fn c1221_l1239_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1240 fn c1222_l1240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1222_l1240_action_invoke"); - let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "div", + &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -11207,7 +15796,10 @@ fn c1222_l1240_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1241 fn c1223_l1241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1223_l1241_action_invoke"); - let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "div", + &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -11215,7 +15807,10 @@ fn c1223_l1241_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1242 fn c1224_l1242_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1224_l1242_action_invoke"); - let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "div", + &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -11255,7 +15850,10 @@ fn c1228_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1247 fn c1229_l1247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1229_l1247_action_invoke"); - let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "div", + &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -11271,7 +15869,10 @@ fn c1230_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1249 fn c1231_l1249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1231_l1249_action_invoke"); - let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "div", + &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -11286,89 +15887,185 @@ fn c1232_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1251 fn c1233_l1251_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1233_l1251_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1233_l1251_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1233_l1251_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1233_l1251_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1252 fn c1234_l1252_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1234_l1252_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1234_l1252_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1234_l1252_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1234_l1252_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1253 fn c1235_l1253_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1235_l1253_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1235_l1253_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1235_l1253_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1235_l1253_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1254 fn c1236_l1254_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1236_l1254_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1236_l1254_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1236_l1254_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1236_l1254_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1255 fn c1237_l1255_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1237_l1255_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1237_l1255_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1237_l1255_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1237_l1255_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1256 fn c1238_l1256_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1238_l1256_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1238_l1256_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1238_l1256_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1238_l1256_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1257 fn c1239_l1257_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1239_l1257_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1239_l1257_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1239_l1257_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1239_l1257_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1258 fn c1240_l1258_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1240_l1258_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1240_l1258_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1240_l1258_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1240_l1258_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -11440,7 +16137,10 @@ fn c1248_l1266_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c1249_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1249_l1267_action_invoke"); let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((0.0000000000000002220446049250313f64)))) + ); result.map(|_| ()) } @@ -11448,7 +16148,10 @@ fn c1249_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c1250_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1250_l1268_action_invoke"); let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000002220446049250313f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((-0.0000000000000002220446049250313f64)))) + ); result.map(|_| ()) } @@ -11456,7 +16159,10 @@ fn c1250_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c1251_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1251_l1269_action_invoke"); let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000002220446049250313f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((-0.0000000000000002220446049250313f64)))) + ); result.map(|_| ()) } @@ -11464,7 +16170,10 @@ fn c1251_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c1252_l1270_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1252_l1270_action_invoke"); let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((0.0000000000000002220446049250313f64)))) + ); result.map(|_| ()) } @@ -11630,89 +16339,113 @@ fn c1272_l1290_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1291 fn c1273_l1291_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1273_l1291_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1273_l1291_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1273_l1291_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1292 fn c1274_l1292_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1274_l1292_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1274_l1292_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1274_l1292_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1293 fn c1275_l1293_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1275_l1293_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1275_l1293_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1275_l1293_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1294 fn c1276_l1294_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1276_l1294_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1276_l1294_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1276_l1294_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1295 fn c1277_l1295_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1277_l1295_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1277_l1295_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1277_l1295_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1296 fn c1278_l1296_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1278_l1296_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1278_l1296_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1278_l1296_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1297 fn c1279_l1297_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1279_l1297_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1279_l1297_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1279_l1297_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1298 fn c1280_l1298_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1280_l1298_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1280_l1298_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1280_l1298_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -11974,89 +16707,113 @@ fn c1312_l1330_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1331 fn c1313_l1331_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1313_l1331_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1313_l1331_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1313_l1331_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1332 fn c1314_l1332_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1314_l1332_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1314_l1332_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1314_l1332_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1333 fn c1315_l1333_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1315_l1333_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1315_l1333_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1315_l1333_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1334 fn c1316_l1334_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1316_l1334_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1316_l1334_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1316_l1334_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1335 fn c1317_l1335_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1317_l1335_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1317_l1335_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1317_l1335_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1336 fn c1318_l1336_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1318_l1336_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1318_l1336_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1318_l1336_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1337 fn c1319_l1337_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1319_l1337_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1319_l1337_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1319_l1337_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1338 fn c1320_l1338_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1320_l1338_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1320_l1338_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1320_l1338_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -12223,7 +16980,10 @@ fn c1340_l1358_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1359 fn c1341_l1359_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1341_l1359_action_invoke"); - let result = instance.call("div", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "div", + &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.07957747154594767f64))))); result.map(|_| ()) } @@ -12231,7 +16991,10 @@ fn c1341_l1359_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1360 fn c1342_l1360_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1342_l1360_action_invoke"); - let result = instance.call("div", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "div", + &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.07957747154594767f64))))); result.map(|_| ()) } @@ -12239,7 +17002,10 @@ fn c1342_l1360_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1361 fn c1343_l1361_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1343_l1361_action_invoke"); - let result = instance.call("div", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "div", + &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.07957747154594767f64))))); result.map(|_| ()) } @@ -12247,7 +17013,10 @@ fn c1343_l1361_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1362 fn c1344_l1362_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1344_l1362_action_invoke"); - let result = instance.call("div", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "div", + &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.07957747154594767f64))))); result.map(|_| ()) } @@ -12287,7 +17056,10 @@ fn c1348_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1367 fn c1349_l1367_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1349_l1367_action_invoke"); - let result = instance.call("div", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "div", + &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -12303,7 +17075,10 @@ fn c1350_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1369 fn c1351_l1369_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1351_l1369_action_invoke"); - let result = instance.call("div", &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "div", + &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -12318,89 +17093,185 @@ fn c1352_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1371 fn c1353_l1371_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1353_l1371_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1353_l1371_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1353_l1371_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1353_l1371_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1372 fn c1354_l1372_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1354_l1372_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1354_l1372_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1354_l1372_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1354_l1372_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1373 fn c1355_l1373_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1355_l1373_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1355_l1373_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1355_l1373_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1355_l1373_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1374 fn c1356_l1374_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1356_l1374_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1356_l1374_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1356_l1374_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1356_l1374_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1375 fn c1357_l1375_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1357_l1375_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1357_l1375_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1357_l1375_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1357_l1375_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1376 fn c1358_l1376_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1358_l1376_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1358_l1376_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1358_l1376_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1358_l1376_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1377 fn c1359_l1377_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1359_l1377_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1359_l1377_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1359_l1377_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1359_l1377_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1378 fn c1360_l1378_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1360_l1378_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1360_l1378_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1360_l1378_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1360_l1378_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -12567,7 +17438,10 @@ fn c1380_l1398_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1399 fn c1381_l1399_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1381_l1399_action_invoke"); - let result = instance.call("div", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "div", + &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.15915494309189535f64))))); result.map(|_| ()) } @@ -12575,7 +17449,10 @@ fn c1381_l1399_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1400 fn c1382_l1400_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1382_l1400_action_invoke"); - let result = instance.call("div", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "div", + &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.15915494309189535f64))))); result.map(|_| ()) } @@ -12583,7 +17460,10 @@ fn c1382_l1400_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1401 fn c1383_l1401_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1383_l1401_action_invoke"); - let result = instance.call("div", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "div", + &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.15915494309189535f64))))); result.map(|_| ()) } @@ -12591,7 +17471,10 @@ fn c1383_l1401_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1402 fn c1384_l1402_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1384_l1402_action_invoke"); - let result = instance.call("div", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "div", + &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.15915494309189535f64))))); result.map(|_| ()) } @@ -12631,7 +17514,10 @@ fn c1388_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1407 fn c1389_l1407_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1389_l1407_action_invoke"); - let result = instance.call("div", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "div", + &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -12647,7 +17533,10 @@ fn c1390_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1409 fn c1391_l1409_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1391_l1409_action_invoke"); - let result = instance.call("div", &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "div", + &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -12662,96 +17551,195 @@ fn c1392_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1411 fn c1393_l1411_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1393_l1411_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1393_l1411_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1393_l1411_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1393_l1411_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1412 fn c1394_l1412_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1394_l1412_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1394_l1412_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1394_l1412_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1394_l1412_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1413 fn c1395_l1413_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1395_l1413_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1395_l1413_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1395_l1413_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1395_l1413_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1414 fn c1396_l1414_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1396_l1414_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1396_l1414_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1396_l1414_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1396_l1414_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1415 fn c1397_l1415_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1397_l1415_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1397_l1415_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1397_l1415_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1397_l1415_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1416 fn c1398_l1416_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1398_l1416_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1398_l1416_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1398_l1416_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1398_l1416_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1417 fn c1399_l1417_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1399_l1417_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1399_l1417_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1399_l1417_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1399_l1417_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1418 fn c1400_l1418_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1400_l1418_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1400_l1418_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1400_l1418_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1400_l1418_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1419 fn c1401_l1419_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1401_l1419_action_invoke"); - let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "div", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -12759,7 +17747,10 @@ fn c1401_l1419_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1420 fn c1402_l1420_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1402_l1420_action_invoke"); - let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "div", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -12767,7 +17758,10 @@ fn c1402_l1420_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1421 fn c1403_l1421_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1403_l1421_action_invoke"); - let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "div", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -12775,7 +17769,10 @@ fn c1403_l1421_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1422 fn c1404_l1422_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1404_l1422_action_invoke"); - let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "div", + &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -12847,7 +17844,10 @@ fn c1412_l1430_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1431 fn c1413_l1431_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1413_l1431_action_invoke"); - let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "div", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((12.566370614359172f64))))); result.map(|_| ()) } @@ -12855,7 +17855,10 @@ fn c1413_l1431_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1432 fn c1414_l1432_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1414_l1432_action_invoke"); - let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "div", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-12.566370614359172f64))))); result.map(|_| ()) } @@ -12863,7 +17866,10 @@ fn c1414_l1432_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1433 fn c1415_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1415_l1433_action_invoke"); - let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "div", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-12.566370614359172f64))))); result.map(|_| ()) } @@ -12871,7 +17877,10 @@ fn c1415_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1434 fn c1416_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1416_l1434_action_invoke"); - let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "div", + &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((12.566370614359172f64))))); result.map(|_| ()) } @@ -12879,7 +17888,10 @@ fn c1416_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1435 fn c1417_l1435_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1417_l1435_action_invoke"); - let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "div", + &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -12887,7 +17899,10 @@ fn c1417_l1435_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1436 fn c1418_l1436_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1418_l1436_action_invoke"); - let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "div", + &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -12895,7 +17910,10 @@ fn c1418_l1436_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1437 fn c1419_l1437_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1419_l1437_action_invoke"); - let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "div", + &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -12903,7 +17921,10 @@ fn c1419_l1437_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1438 fn c1420_l1438_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1420_l1438_action_invoke"); - let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "div", + &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -12911,7 +17932,13 @@ fn c1420_l1438_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1439 fn c1421_l1439_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1421_l1439_action_invoke"); - let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "div", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -12919,7 +17946,13 @@ fn c1421_l1439_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1440 fn c1422_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1422_l1440_action_invoke"); - let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "div", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -12927,7 +17960,13 @@ fn c1422_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1441 fn c1423_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1423_l1441_action_invoke"); - let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "div", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -12935,7 +17974,13 @@ fn c1423_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1442 fn c1424_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1424_l1442_action_invoke"); - let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "div", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -12975,7 +18020,13 @@ fn c1428_l1446_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1447 fn c1429_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1429_l1447_action_invoke"); - let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -12983,7 +18034,13 @@ fn c1429_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1448 fn c1430_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1430_l1448_action_invoke"); - let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -12991,7 +18048,13 @@ fn c1430_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1449 fn c1431_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1431_l1449_action_invoke"); - let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -12999,96 +18062,198 @@ fn c1431_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1450 fn c1432_l1450_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1432_l1450_action_invoke"); - let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "div", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } // Line 1451 fn c1433_l1451_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1433_l1451_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1433_l1451_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1433_l1451_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1433_l1451_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1452 fn c1434_l1452_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1434_l1452_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1434_l1452_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1434_l1452_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1434_l1452_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1453 fn c1435_l1453_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1435_l1453_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1435_l1453_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1435_l1453_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1435_l1453_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1454 fn c1436_l1454_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1436_l1454_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1436_l1454_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1436_l1454_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1436_l1454_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1455 fn c1437_l1455_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1437_l1455_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1437_l1455_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1437_l1455_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1437_l1455_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1456 fn c1438_l1456_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1438_l1456_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1438_l1456_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1438_l1456_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1438_l1456_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1457 fn c1439_l1457_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1439_l1457_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1439_l1457_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1439_l1457_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1439_l1457_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1458 fn c1440_l1458_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1440_l1458_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1440_l1458_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1440_l1458_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1440_l1458_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -13350,96 +18515,123 @@ fn c1472_l1490_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1491 fn c1473_l1491_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1473_l1491_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1473_l1491_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1473_l1491_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1492 fn c1474_l1492_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1474_l1492_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1474_l1492_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1474_l1492_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1493 fn c1475_l1493_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1475_l1493_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1475_l1493_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1475_l1493_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1494 fn c1476_l1494_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1476_l1494_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1476_l1494_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1476_l1494_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1495 fn c1477_l1495_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1477_l1495_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1477_l1495_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1477_l1495_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1496 fn c1478_l1496_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1478_l1496_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1478_l1496_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1478_l1496_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1497 fn c1479_l1497_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1479_l1497_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1479_l1497_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1479_l1497_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1498 fn c1480_l1498_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1480_l1498_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1480_l1498_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1480_l1498_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1499 fn c1481_l1499_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1481_l1499_action_invoke"); - let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]); + let result = instance.call( + "div", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -13447,7 +18639,10 @@ fn c1481_l1499_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1500 fn c1482_l1500_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1482_l1500_action_invoke"); - let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))]); + let result = instance.call( + "div", + &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -13535,7 +18730,10 @@ fn c1492_l1510_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1511 fn c1493_l1511_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1493_l1511_action_invoke"); - let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]); + let result = instance.call( + "div", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -13543,7 +18741,10 @@ fn c1493_l1511_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1512 fn c1494_l1512_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1494_l1512_action_invoke"); - let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))]); + let result = instance.call( + "div", + &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -13567,7 +18768,10 @@ fn c1496_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1515 fn c1497_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1497_l1515_action_invoke"); - let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]); + let result = instance.call( + "div", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -13575,7 +18779,10 @@ fn c1497_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1516 fn c1498_l1516_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1498_l1516_action_invoke"); - let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))]); + let result = instance.call( + "div", + &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -13599,7 +18806,13 @@ fn c1500_l1518_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1519 fn c1501_l1519_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1501_l1519_action_invoke"); - let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "div", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -13607,7 +18820,13 @@ fn c1501_l1519_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1520 fn c1502_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1502_l1520_action_invoke"); - let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "div", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -13615,7 +18834,13 @@ fn c1502_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1521 fn c1503_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1503_l1521_action_invoke"); - let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "div", + &[ + Value::F64(f64::INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -13623,7 +18848,13 @@ fn c1503_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1522 fn c1504_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1504_l1522_action_invoke"); - let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "div", + &[ + Value::F64(f64::INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -13662,1013 +18893,1889 @@ fn c1508_l1526_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1527 fn c1509_l1527_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1509_l1527_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1509_l1527_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1509_l1527_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)], + ) + .unwrap() + .expect("Missing result in c1509_l1527_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1528 fn c1510_l1528_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1510_l1528_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1510_l1528_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1510_l1528_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)], + ) + .unwrap() + .expect("Missing result in c1510_l1528_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1529 fn c1511_l1529_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1511_l1529_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1511_l1529_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1511_l1529_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)], + ) + .unwrap() + .expect("Missing result in c1511_l1529_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1530 fn c1512_l1530_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1512_l1530_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1512_l1530_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1512_l1530_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)], + ) + .unwrap() + .expect("Missing result in c1512_l1530_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1531 fn c1513_l1531_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1513_l1531_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1513_l1531_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1513_l1531_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1513_l1531_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1532 fn c1514_l1532_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1514_l1532_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1514_l1532_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1514_l1532_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1514_l1532_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1533 fn c1515_l1533_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1515_l1533_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1515_l1533_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1515_l1533_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1515_l1533_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1534 fn c1516_l1534_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1516_l1534_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1516_l1534_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1516_l1534_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1516_l1534_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1535 fn c1517_l1535_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1517_l1535_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1517_l1535_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1517_l1535_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1517_l1535_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1536 fn c1518_l1536_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1518_l1536_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1518_l1536_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1518_l1536_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1518_l1536_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1537 fn c1519_l1537_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1519_l1537_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1519_l1537_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1519_l1537_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1519_l1537_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1538 fn c1520_l1538_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1520_l1538_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1520_l1538_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1520_l1538_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1520_l1538_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1539 fn c1521_l1539_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1521_l1539_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1521_l1539_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1521_l1539_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1521_l1539_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1540 fn c1522_l1540_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1522_l1540_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1522_l1540_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1522_l1540_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1522_l1540_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1541 fn c1523_l1541_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1523_l1541_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1523_l1541_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1523_l1541_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1523_l1541_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1542 fn c1524_l1542_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1524_l1542_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1524_l1542_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1524_l1542_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1524_l1542_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1543 fn c1525_l1543_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1525_l1543_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1525_l1543_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1525_l1543_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1525_l1543_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1544 fn c1526_l1544_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1526_l1544_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1526_l1544_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1526_l1544_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1526_l1544_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1545 fn c1527_l1545_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1527_l1545_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1527_l1545_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1527_l1545_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1527_l1545_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1546 fn c1528_l1546_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1528_l1546_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1528_l1546_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1528_l1546_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1528_l1546_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1547 fn c1529_l1547_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1529_l1547_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1529_l1547_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1529_l1547_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1548 fn c1530_l1548_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1530_l1548_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1530_l1548_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1530_l1548_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1549 fn c1531_l1549_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1531_l1549_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1531_l1549_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1531_l1549_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1550 fn c1532_l1550_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1532_l1550_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1532_l1550_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1532_l1550_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1551 fn c1533_l1551_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1533_l1551_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1533_l1551_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1533_l1551_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1552 fn c1534_l1552_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1534_l1552_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1534_l1552_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1534_l1552_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1553 fn c1535_l1553_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1535_l1553_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1535_l1553_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1535_l1553_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1554 fn c1536_l1554_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1536_l1554_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1536_l1554_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1536_l1554_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1555 fn c1537_l1555_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1537_l1555_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1537_l1555_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1537_l1555_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1556 fn c1538_l1556_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1538_l1556_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1538_l1556_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1538_l1556_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1557 fn c1539_l1557_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1539_l1557_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1539_l1557_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1539_l1557_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1558 fn c1540_l1558_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1540_l1558_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1540_l1558_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1540_l1558_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1559 fn c1541_l1559_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1541_l1559_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1541_l1559_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1541_l1559_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1560 fn c1542_l1560_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1542_l1560_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1542_l1560_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1542_l1560_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1561 fn c1543_l1561_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1543_l1561_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1543_l1561_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1543_l1561_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1562 fn c1544_l1562_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1544_l1562_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1544_l1562_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1544_l1562_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1563 fn c1545_l1563_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1545_l1563_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1545_l1563_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1545_l1563_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1545_l1563_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1564 fn c1546_l1564_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1546_l1564_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1546_l1564_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1546_l1564_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1546_l1564_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1565 fn c1547_l1565_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1547_l1565_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1547_l1565_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1547_l1565_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1547_l1565_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1566 fn c1548_l1566_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1548_l1566_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1548_l1566_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1548_l1566_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1548_l1566_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1567 fn c1549_l1567_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1549_l1567_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1549_l1567_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1549_l1567_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1549_l1567_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1568 fn c1550_l1568_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1550_l1568_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1550_l1568_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1550_l1568_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1550_l1568_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1569 fn c1551_l1569_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1551_l1569_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1551_l1569_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1551_l1569_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1551_l1569_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1570 fn c1552_l1570_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1552_l1570_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1552_l1570_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1552_l1570_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1552_l1570_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1571 fn c1553_l1571_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1553_l1571_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1553_l1571_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1553_l1571_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1553_l1571_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1572 fn c1554_l1572_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1554_l1572_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1554_l1572_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1554_l1572_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1554_l1572_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1573 fn c1555_l1573_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1555_l1573_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1555_l1573_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1555_l1573_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1555_l1573_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1574 fn c1556_l1574_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1556_l1574_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1556_l1574_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1556_l1574_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1556_l1574_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1575 fn c1557_l1575_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1557_l1575_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1557_l1575_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1557_l1575_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1557_l1575_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1576 fn c1558_l1576_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1558_l1576_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1558_l1576_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1558_l1576_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1558_l1576_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1577 fn c1559_l1577_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1559_l1577_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1559_l1577_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1559_l1577_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1559_l1577_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1578 fn c1560_l1578_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1560_l1578_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1560_l1578_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1560_l1578_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1560_l1578_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1579 fn c1561_l1579_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1561_l1579_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1561_l1579_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1561_l1579_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1561_l1579_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1580 fn c1562_l1580_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1562_l1580_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1562_l1580_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1562_l1580_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1562_l1580_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1581 fn c1563_l1581_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1563_l1581_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1563_l1581_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1563_l1581_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1563_l1581_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1582 fn c1564_l1582_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1564_l1582_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1564_l1582_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1564_l1582_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1564_l1582_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1583 fn c1565_l1583_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1565_l1583_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1565_l1583_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1565_l1583_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1565_l1583_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1584 fn c1566_l1584_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1566_l1584_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1566_l1584_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1566_l1584_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1566_l1584_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1585 fn c1567_l1585_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1567_l1585_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1567_l1585_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1567_l1585_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1567_l1585_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1586 fn c1568_l1586_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1568_l1586_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1568_l1586_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1568_l1586_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1568_l1586_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1587 fn c1569_l1587_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1569_l1587_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1569_l1587_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1569_l1587_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1588 fn c1570_l1588_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1570_l1588_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1570_l1588_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1570_l1588_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1589 fn c1571_l1589_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1571_l1589_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1571_l1589_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1571_l1589_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1590 fn c1572_l1590_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1572_l1590_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1572_l1590_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1572_l1590_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1591 fn c1573_l1591_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1573_l1591_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1573_l1591_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1573_l1591_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1592 fn c1574_l1592_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1574_l1592_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1574_l1592_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1574_l1592_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1593 fn c1575_l1593_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1575_l1593_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1575_l1593_assert_return_canonical_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1575_l1593_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1594 fn c1576_l1594_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1576_l1594_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1576_l1594_assert_return_arithmetic_nan" + ); let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1576_l1594_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1595 fn c1577_l1595_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1577_l1595_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1577_l1595_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1577_l1595_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1577_l1595_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1596 fn c1578_l1596_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1578_l1596_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1578_l1596_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1578_l1596_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1578_l1596_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1597 fn c1579_l1597_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1579_l1597_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1579_l1597_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1579_l1597_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1579_l1597_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1598 fn c1580_l1598_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1580_l1598_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1580_l1598_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1580_l1598_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1580_l1598_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1599 fn c1581_l1599_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1581_l1599_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1581_l1599_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1581_l1599_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1581_l1599_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1600 fn c1582_l1600_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1582_l1600_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1582_l1600_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1582_l1600_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1582_l1600_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1601 fn c1583_l1601_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1583_l1601_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1583_l1601_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1583_l1601_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1583_l1601_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1602 fn c1584_l1602_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1584_l1602_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1584_l1602_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1584_l1602_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1584_l1602_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1603 fn c1585_l1603_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1585_l1603_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1585_l1603_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1585_l1603_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1585_l1603_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1604 fn c1586_l1604_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1586_l1604_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1586_l1604_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1586_l1604_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1586_l1604_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1605 fn c1587_l1605_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1587_l1605_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1587_l1605_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1587_l1605_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1587_l1605_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1606 fn c1588_l1606_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1588_l1606_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1588_l1606_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1588_l1606_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1588_l1606_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1607 fn c1589_l1607_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1589_l1607_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1589_l1607_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1589_l1607_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1589_l1607_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1608 fn c1590_l1608_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1590_l1608_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1590_l1608_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1590_l1608_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1590_l1608_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1609 fn c1591_l1609_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1591_l1609_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1591_l1609_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1591_l1609_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1591_l1609_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1610 fn c1592_l1610_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1592_l1610_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1592_l1610_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1592_l1610_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1592_l1610_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1611 fn c1593_l1611_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1593_l1611_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1593_l1611_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1593_l1611_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1593_l1611_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1612 fn c1594_l1612_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1594_l1612_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1594_l1612_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1594_l1612_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1594_l1612_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1613 fn c1595_l1613_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1595_l1613_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1595_l1613_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1595_l1613_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1595_l1613_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1614 fn c1596_l1614_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1596_l1614_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1596_l1614_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1596_l1614_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1596_l1614_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1615 fn c1597_l1615_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1597_l1615_assert_return_canonical_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1597_l1615_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1597_l1615_assert_return_canonical_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1597_l1615_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1616 fn c1598_l1616_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1598_l1616_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1598_l1616_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1598_l1616_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1598_l1616_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1617 fn c1599_l1617_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1599_l1617_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1599_l1617_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1599_l1617_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1599_l1617_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1618 fn c1600_l1618_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1600_l1618_assert_return_arithmetic_nan"); - let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1600_l1618_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1600_l1618_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "div", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1600_l1618_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -14835,7 +20942,10 @@ fn c1620_l1638_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1639 fn c1621_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1621_l1639_action_invoke"); - let result = instance.call("min", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "min", + &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -14843,7 +20953,10 @@ fn c1621_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1640 fn c1622_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1622_l1640_action_invoke"); - let result = instance.call("min", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "min", + &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -14851,7 +20964,10 @@ fn c1622_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1641 fn c1623_l1641_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1623_l1641_action_invoke"); - let result = instance.call("min", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "min", + &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -14859,7 +20975,10 @@ fn c1623_l1641_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1642 fn c1624_l1642_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1624_l1642_action_invoke"); - let result = instance.call("min", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "min", + &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -14899,7 +21018,10 @@ fn c1628_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1647 fn c1629_l1647_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1629_l1647_action_invoke"); - let result = instance.call("min", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -14915,7 +21037,10 @@ fn c1630_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1649 fn c1631_l1649_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1631_l1649_action_invoke"); - let result = instance.call("min", &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -14930,89 +21055,185 @@ fn c1632_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1651 fn c1633_l1651_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1633_l1651_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1633_l1651_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1633_l1651_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1633_l1651_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1652 fn c1634_l1652_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1634_l1652_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1634_l1652_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1634_l1652_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1634_l1652_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1653 fn c1635_l1653_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1635_l1653_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1635_l1653_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1635_l1653_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1635_l1653_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1654 fn c1636_l1654_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1636_l1654_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1636_l1654_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1636_l1654_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1636_l1654_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1655 fn c1637_l1655_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1637_l1655_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1637_l1655_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1637_l1655_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1637_l1655_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1656 fn c1638_l1656_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1638_l1656_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1638_l1656_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1638_l1656_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1638_l1656_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1657 fn c1639_l1657_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1639_l1657_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1639_l1657_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1639_l1657_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1639_l1657_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1658 fn c1640_l1658_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1640_l1658_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1640_l1658_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1640_l1658_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1640_l1658_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -15274,89 +21495,113 @@ fn c1672_l1690_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1691 fn c1673_l1691_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1673_l1691_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1673_l1691_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1673_l1691_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1692 fn c1674_l1692_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1674_l1692_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1674_l1692_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1674_l1692_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1693 fn c1675_l1693_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1675_l1693_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1675_l1693_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1675_l1693_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1694 fn c1676_l1694_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1676_l1694_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1676_l1694_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1676_l1694_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1695 fn c1677_l1695_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1677_l1695_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1677_l1695_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1677_l1695_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1696 fn c1678_l1696_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1678_l1696_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1678_l1696_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1678_l1696_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1697 fn c1679_l1697_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1679_l1697_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1679_l1697_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1679_l1697_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1698 fn c1680_l1698_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1680_l1698_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1680_l1698_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1680_l1698_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -15618,89 +21863,113 @@ fn c1712_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1731 fn c1713_l1731_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1713_l1731_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1713_l1731_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1713_l1731_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1732 fn c1714_l1732_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1714_l1732_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1714_l1732_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1714_l1732_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1733 fn c1715_l1733_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1715_l1733_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1715_l1733_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1715_l1733_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1734 fn c1716_l1734_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1716_l1734_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1716_l1734_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1716_l1734_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1735 fn c1717_l1735_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1717_l1735_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1717_l1735_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1717_l1735_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1736 fn c1718_l1736_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1718_l1736_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1718_l1736_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1718_l1736_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1737 fn c1719_l1737_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1719_l1737_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1719_l1737_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1719_l1737_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1738 fn c1720_l1738_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1720_l1738_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1720_l1738_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1720_l1738_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -15867,7 +22136,10 @@ fn c1740_l1758_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1759 fn c1741_l1759_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1741_l1759_action_invoke"); - let result = instance.call("min", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "min", + &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -15875,7 +22147,10 @@ fn c1741_l1759_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1760 fn c1742_l1760_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1742_l1760_action_invoke"); - let result = instance.call("min", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "min", + &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.5f64))))); result.map(|_| ()) } @@ -15883,7 +22158,10 @@ fn c1742_l1760_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1761 fn c1743_l1761_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1743_l1761_action_invoke"); - let result = instance.call("min", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "min", + &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -15891,7 +22169,10 @@ fn c1743_l1761_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1762 fn c1744_l1762_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1744_l1762_action_invoke"); - let result = instance.call("min", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "min", + &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.5f64))))); result.map(|_| ()) } @@ -15931,7 +22212,10 @@ fn c1748_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1767 fn c1749_l1767_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1749_l1767_action_invoke"); - let result = instance.call("min", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -15947,7 +22231,10 @@ fn c1750_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1769 fn c1751_l1769_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1751_l1769_action_invoke"); - let result = instance.call("min", &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -15962,89 +22249,185 @@ fn c1752_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1771 fn c1753_l1771_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1753_l1771_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1753_l1771_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1753_l1771_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1753_l1771_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1772 fn c1754_l1772_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1754_l1772_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1754_l1772_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1754_l1772_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1754_l1772_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1773 fn c1755_l1773_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1755_l1773_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1755_l1773_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1755_l1773_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1755_l1773_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1774 fn c1756_l1774_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1756_l1774_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1756_l1774_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1756_l1774_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1756_l1774_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1775 fn c1757_l1775_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1757_l1775_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1757_l1775_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1757_l1775_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1757_l1775_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1776 fn c1758_l1776_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1758_l1776_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1758_l1776_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1758_l1776_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1758_l1776_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1777 fn c1759_l1777_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1759_l1777_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1759_l1777_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1759_l1777_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1759_l1777_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1778 fn c1760_l1778_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1760_l1778_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1760_l1778_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1760_l1778_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1760_l1778_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -16211,7 +22594,10 @@ fn c1780_l1798_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1799 fn c1781_l1799_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1781_l1799_action_invoke"); - let result = instance.call("min", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "min", + &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -16219,7 +22605,10 @@ fn c1781_l1799_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1800 fn c1782_l1800_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1782_l1800_action_invoke"); - let result = instance.call("min", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "min", + &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -16227,7 +22616,10 @@ fn c1782_l1800_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1801 fn c1783_l1801_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1783_l1801_action_invoke"); - let result = instance.call("min", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "min", + &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -16235,7 +22627,10 @@ fn c1783_l1801_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1802 fn c1784_l1802_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1784_l1802_action_invoke"); - let result = instance.call("min", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "min", + &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -16275,7 +22670,10 @@ fn c1788_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1807 fn c1789_l1807_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1789_l1807_action_invoke"); - let result = instance.call("min", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -16291,7 +22689,10 @@ fn c1790_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1809 fn c1791_l1809_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1791_l1809_action_invoke"); - let result = instance.call("min", &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -16306,96 +22707,195 @@ fn c1792_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1811 fn c1793_l1811_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1793_l1811_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1793_l1811_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1793_l1811_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1793_l1811_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1812 fn c1794_l1812_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1794_l1812_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1794_l1812_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1794_l1812_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1794_l1812_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1813 fn c1795_l1813_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1795_l1813_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1795_l1813_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1795_l1813_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1795_l1813_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1814 fn c1796_l1814_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1796_l1814_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1796_l1814_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1796_l1814_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1796_l1814_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1815 fn c1797_l1815_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1797_l1815_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1797_l1815_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1797_l1815_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1797_l1815_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1816 fn c1798_l1816_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1798_l1816_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1798_l1816_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1798_l1816_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1798_l1816_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1817 fn c1799_l1817_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1799_l1817_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1799_l1817_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1799_l1817_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1799_l1817_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1818 fn c1800_l1818_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1800_l1818_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1800_l1818_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1800_l1818_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1800_l1818_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1819 fn c1801_l1819_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1801_l1819_action_invoke"); - let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "min", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -16403,7 +22903,10 @@ fn c1801_l1819_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1820 fn c1802_l1820_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1802_l1820_action_invoke"); - let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "min", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -16411,7 +22914,10 @@ fn c1802_l1820_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1821 fn c1803_l1821_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1803_l1821_action_invoke"); - let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "min", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -16419,7 +22925,10 @@ fn c1803_l1821_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1822 fn c1804_l1822_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1804_l1822_action_invoke"); - let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "min", + &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -16491,7 +23000,10 @@ fn c1812_l1830_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1831 fn c1813_l1831_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1813_l1831_action_invoke"); - let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "min", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -16499,7 +23011,10 @@ fn c1813_l1831_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1832 fn c1814_l1832_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1814_l1832_action_invoke"); - let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "min", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -16507,7 +23022,10 @@ fn c1814_l1832_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1833 fn c1815_l1833_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1815_l1833_action_invoke"); - let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "min", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.5f64))))); result.map(|_| ()) } @@ -16515,7 +23033,10 @@ fn c1815_l1833_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1834 fn c1816_l1834_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1816_l1834_action_invoke"); - let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "min", + &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.5f64))))); result.map(|_| ()) } @@ -16523,7 +23044,10 @@ fn c1816_l1834_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1835 fn c1817_l1835_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1817_l1835_action_invoke"); - let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "min", + &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -16531,7 +23055,10 @@ fn c1817_l1835_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1836 fn c1818_l1836_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1818_l1836_action_invoke"); - let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "min", + &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -16539,7 +23066,10 @@ fn c1818_l1836_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1837 fn c1819_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1819_l1837_action_invoke"); - let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "min", + &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -16547,7 +23077,10 @@ fn c1819_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1838 fn c1820_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1820_l1838_action_invoke"); - let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "min", + &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -16555,7 +23088,13 @@ fn c1820_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1839 fn c1821_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1821_l1839_action_invoke"); - let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "min", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -16563,7 +23102,13 @@ fn c1821_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1840 fn c1822_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1822_l1840_action_invoke"); - let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "min", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -16571,7 +23116,13 @@ fn c1822_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1841 fn c1823_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1823_l1841_action_invoke"); - let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "min", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -16579,7 +23130,13 @@ fn c1823_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1842 fn c1824_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1824_l1842_action_invoke"); - let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "min", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -16619,7 +23176,13 @@ fn c1828_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1847 fn c1829_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1829_l1847_action_invoke"); - let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "min", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -16627,7 +23190,13 @@ fn c1829_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1848 fn c1830_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1830_l1848_action_invoke"); - let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "min", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -16635,7 +23204,13 @@ fn c1830_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1849 fn c1831_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1831_l1849_action_invoke"); - let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "min", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -16643,96 +23218,198 @@ fn c1831_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1850 fn c1832_l1850_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1832_l1850_action_invoke"); - let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "min", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } // Line 1851 fn c1833_l1851_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1833_l1851_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1833_l1851_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1833_l1851_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1833_l1851_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1852 fn c1834_l1852_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1834_l1852_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1834_l1852_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1834_l1852_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1834_l1852_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1853 fn c1835_l1853_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1835_l1853_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1835_l1853_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1835_l1853_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1835_l1853_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1854 fn c1836_l1854_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1836_l1854_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1836_l1854_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1836_l1854_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1836_l1854_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1855 fn c1837_l1855_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1837_l1855_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1837_l1855_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1837_l1855_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1837_l1855_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1856 fn c1838_l1856_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1838_l1856_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1838_l1856_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1838_l1856_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1838_l1856_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1857 fn c1839_l1857_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1839_l1857_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1839_l1857_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1839_l1857_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1839_l1857_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1858 fn c1840_l1858_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1840_l1858_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1840_l1858_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1840_l1858_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1840_l1858_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -16994,96 +23671,123 @@ fn c1872_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1891 fn c1873_l1891_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1873_l1891_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1873_l1891_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1873_l1891_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1892 fn c1874_l1892_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1874_l1892_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1874_l1892_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1874_l1892_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1893 fn c1875_l1893_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1875_l1893_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1875_l1893_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1875_l1893_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1894 fn c1876_l1894_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1876_l1894_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1876_l1894_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1876_l1894_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1895 fn c1877_l1895_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1877_l1895_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1877_l1895_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1877_l1895_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1896 fn c1878_l1896_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1878_l1896_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1878_l1896_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1878_l1896_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1897 fn c1879_l1897_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1879_l1897_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1879_l1897_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1879_l1897_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1898 fn c1880_l1898_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1880_l1898_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1880_l1898_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1880_l1898_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1899 fn c1881_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1881_l1899_action_invoke"); - let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]); + let result = instance.call( + "min", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -17091,7 +23795,10 @@ fn c1881_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1900 fn c1882_l1900_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1882_l1900_action_invoke"); - let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))]); + let result = instance.call( + "min", + &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -17179,7 +23886,10 @@ fn c1892_l1910_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1911 fn c1893_l1911_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1893_l1911_action_invoke"); - let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]); + let result = instance.call( + "min", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -17187,7 +23897,10 @@ fn c1893_l1911_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1912 fn c1894_l1912_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1894_l1912_action_invoke"); - let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))]); + let result = instance.call( + "min", + &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -17211,7 +23924,10 @@ fn c1896_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1915 fn c1897_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1897_l1915_action_invoke"); - let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]); + let result = instance.call( + "min", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -17219,7 +23935,10 @@ fn c1897_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1916 fn c1898_l1916_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1898_l1916_action_invoke"); - let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))]); + let result = instance.call( + "min", + &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -17243,7 +23962,13 @@ fn c1900_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1919 fn c1901_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1901_l1919_action_invoke"); - let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "min", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -17251,7 +23976,13 @@ fn c1901_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1920 fn c1902_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1902_l1920_action_invoke"); - let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "min", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -17259,7 +23990,13 @@ fn c1902_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1921 fn c1903_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1903_l1921_action_invoke"); - let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "min", + &[ + Value::F64(f64::INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -17267,7 +24004,13 @@ fn c1903_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1922 fn c1904_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1904_l1922_action_invoke"); - let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "min", + &[ + Value::F64(f64::INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -17307,7 +24050,10 @@ fn c1908_l1926_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1927 fn c1909_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1909_l1927_action_invoke"); - let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -17315,7 +24061,10 @@ fn c1909_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1928 fn c1910_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1910_l1928_action_invoke"); - let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "min", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -17323,7 +24072,10 @@ fn c1910_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1929 fn c1911_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1911_l1929_action_invoke"); - let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "min", + &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -17331,976 +24083,1819 @@ fn c1911_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1930 fn c1912_l1930_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1912_l1930_action_invoke"); - let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "min", + &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } // Line 1931 fn c1913_l1931_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1913_l1931_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1913_l1931_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1913_l1931_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1913_l1931_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1932 fn c1914_l1932_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1914_l1932_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1914_l1932_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1914_l1932_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1914_l1932_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1933 fn c1915_l1933_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1915_l1933_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1915_l1933_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1915_l1933_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1915_l1933_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1934 fn c1916_l1934_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1916_l1934_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1916_l1934_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1916_l1934_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1916_l1934_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1935 fn c1917_l1935_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1917_l1935_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1917_l1935_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1917_l1935_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1917_l1935_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1936 fn c1918_l1936_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1918_l1936_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1918_l1936_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1918_l1936_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1918_l1936_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1937 fn c1919_l1937_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1919_l1937_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1919_l1937_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1919_l1937_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1919_l1937_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1938 fn c1920_l1938_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1920_l1938_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1920_l1938_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1920_l1938_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1920_l1938_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1939 fn c1921_l1939_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1921_l1939_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1921_l1939_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1921_l1939_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1921_l1939_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1940 fn c1922_l1940_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1922_l1940_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1922_l1940_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1922_l1940_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1922_l1940_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1941 fn c1923_l1941_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1923_l1941_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1923_l1941_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1923_l1941_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1923_l1941_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1942 fn c1924_l1942_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1924_l1942_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1924_l1942_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1924_l1942_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1924_l1942_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1943 fn c1925_l1943_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1925_l1943_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1925_l1943_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1925_l1943_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1925_l1943_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1944 fn c1926_l1944_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1926_l1944_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c1926_l1944_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1926_l1944_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1926_l1944_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1945 fn c1927_l1945_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1927_l1945_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1927_l1945_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1927_l1945_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1927_l1945_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1946 fn c1928_l1946_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1928_l1946_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c1928_l1946_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1928_l1946_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1928_l1946_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1947 fn c1929_l1947_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1929_l1947_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1929_l1947_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1929_l1947_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1948 fn c1930_l1948_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1930_l1948_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1930_l1948_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1930_l1948_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1949 fn c1931_l1949_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1931_l1949_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1931_l1949_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1931_l1949_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1950 fn c1932_l1950_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1932_l1950_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1932_l1950_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1932_l1950_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1951 fn c1933_l1951_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1933_l1951_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1933_l1951_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1933_l1951_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1952 fn c1934_l1952_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1934_l1952_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1934_l1952_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1934_l1952_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1953 fn c1935_l1953_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1935_l1953_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1935_l1953_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1935_l1953_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1954 fn c1936_l1954_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1936_l1954_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1936_l1954_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c1936_l1954_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1955 fn c1937_l1955_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1937_l1955_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1937_l1955_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1937_l1955_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1956 fn c1938_l1956_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1938_l1956_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1938_l1956_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1938_l1956_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1957 fn c1939_l1957_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1939_l1957_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1939_l1957_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1939_l1957_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1958 fn c1940_l1958_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1940_l1958_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1940_l1958_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1940_l1958_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1959 fn c1941_l1959_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1941_l1959_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1941_l1959_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1941_l1959_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1960 fn c1942_l1960_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1942_l1960_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1942_l1960_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1942_l1960_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1961 fn c1943_l1961_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1943_l1961_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1943_l1961_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1943_l1961_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1962 fn c1944_l1962_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1944_l1962_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1944_l1962_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c1944_l1962_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1963 fn c1945_l1963_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1945_l1963_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1945_l1963_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1945_l1963_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1945_l1963_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1964 fn c1946_l1964_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1946_l1964_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1946_l1964_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1946_l1964_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1946_l1964_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1965 fn c1947_l1965_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1947_l1965_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1947_l1965_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1947_l1965_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1947_l1965_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1966 fn c1948_l1966_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1948_l1966_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1948_l1966_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1948_l1966_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1948_l1966_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1967 fn c1949_l1967_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1949_l1967_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1949_l1967_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1949_l1967_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1949_l1967_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1968 fn c1950_l1968_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1950_l1968_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c1950_l1968_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1950_l1968_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1950_l1968_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1969 fn c1951_l1969_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1951_l1969_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1951_l1969_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1951_l1969_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1951_l1969_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1970 fn c1952_l1970_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1952_l1970_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c1952_l1970_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1952_l1970_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c1952_l1970_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1971 fn c1953_l1971_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1953_l1971_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1953_l1971_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1953_l1971_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1953_l1971_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1972 fn c1954_l1972_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1954_l1972_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1954_l1972_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1954_l1972_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1954_l1972_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1973 fn c1955_l1973_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1955_l1973_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1955_l1973_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1955_l1973_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1955_l1973_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1974 fn c1956_l1974_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1956_l1974_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1956_l1974_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1956_l1974_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1956_l1974_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1975 fn c1957_l1975_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1957_l1975_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1957_l1975_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1957_l1975_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1957_l1975_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1976 fn c1958_l1976_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1958_l1976_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c1958_l1976_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1958_l1976_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1958_l1976_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1977 fn c1959_l1977_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1959_l1977_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1959_l1977_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1959_l1977_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1959_l1977_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1978 fn c1960_l1978_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1960_l1978_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c1960_l1978_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1960_l1978_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c1960_l1978_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1979 fn c1961_l1979_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1961_l1979_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1961_l1979_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1961_l1979_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1961_l1979_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1980 fn c1962_l1980_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1962_l1980_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1962_l1980_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1962_l1980_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1962_l1980_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1981 fn c1963_l1981_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1963_l1981_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1963_l1981_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1963_l1981_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1963_l1981_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1982 fn c1964_l1982_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1964_l1982_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1964_l1982_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1964_l1982_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1964_l1982_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1983 fn c1965_l1983_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1965_l1983_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1965_l1983_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1965_l1983_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1965_l1983_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1984 fn c1966_l1984_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1966_l1984_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c1966_l1984_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1966_l1984_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1966_l1984_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1985 fn c1967_l1985_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1967_l1985_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1967_l1985_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1967_l1985_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1967_l1985_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1986 fn c1968_l1986_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1968_l1986_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c1968_l1986_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1968_l1986_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c1968_l1986_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1987 fn c1969_l1987_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1969_l1987_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1969_l1987_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1969_l1987_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1988 fn c1970_l1988_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1970_l1988_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1970_l1988_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1970_l1988_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1989 fn c1971_l1989_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1971_l1989_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1971_l1989_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1971_l1989_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1990 fn c1972_l1990_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1972_l1990_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1972_l1990_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1972_l1990_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1991 fn c1973_l1991_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1973_l1991_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1973_l1991_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1973_l1991_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1992 fn c1974_l1992_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1974_l1992_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1974_l1992_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1974_l1992_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1993 fn c1975_l1993_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1975_l1993_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1975_l1993_assert_return_canonical_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1975_l1993_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1994 fn c1976_l1994_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1976_l1994_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1976_l1994_assert_return_arithmetic_nan" + ); let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c1976_l1994_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1995 fn c1977_l1995_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1977_l1995_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1977_l1995_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1977_l1995_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1977_l1995_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1996 fn c1978_l1996_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1978_l1996_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1978_l1996_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1978_l1996_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1978_l1996_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1997 fn c1979_l1997_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1979_l1997_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1979_l1997_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1979_l1997_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1979_l1997_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1998 fn c1980_l1998_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1980_l1998_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1980_l1998_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1980_l1998_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1980_l1998_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1999 fn c1981_l1999_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1981_l1999_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1981_l1999_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1981_l1999_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1981_l1999_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2000 fn c1982_l2000_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1982_l2000_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c1982_l2000_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1982_l2000_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1982_l2000_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2001 fn c1983_l2001_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1983_l2001_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1983_l2001_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1983_l2001_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1983_l2001_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2002 fn c1984_l2002_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1984_l2002_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c1984_l2002_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1984_l2002_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c1984_l2002_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2003 fn c1985_l2003_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1985_l2003_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1985_l2003_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1985_l2003_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1985_l2003_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2004 fn c1986_l2004_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1986_l2004_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1986_l2004_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1986_l2004_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1986_l2004_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2005 fn c1987_l2005_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1987_l2005_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1987_l2005_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1987_l2005_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1987_l2005_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2006 fn c1988_l2006_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1988_l2006_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1988_l2006_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1988_l2006_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1988_l2006_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2007 fn c1989_l2007_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1989_l2007_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1989_l2007_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1989_l2007_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1989_l2007_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2008 fn c1990_l2008_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1990_l2008_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1990_l2008_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1990_l2008_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1990_l2008_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2009 fn c1991_l2009_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1991_l2009_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1991_l2009_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1991_l2009_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1991_l2009_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2010 fn c1992_l2010_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1992_l2010_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1992_l2010_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1992_l2010_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1992_l2010_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2011 fn c1993_l2011_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1993_l2011_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1993_l2011_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1993_l2011_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1993_l2011_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2012 fn c1994_l2012_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1994_l2012_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c1994_l2012_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1994_l2012_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c1994_l2012_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2013 fn c1995_l2013_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1995_l2013_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1995_l2013_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1995_l2013_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1995_l2013_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2014 fn c1996_l2014_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1996_l2014_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c1996_l2014_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1996_l2014_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c1996_l2014_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2015 fn c1997_l2015_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c1997_l2015_assert_return_canonical_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1997_l2015_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c1997_l2015_assert_return_canonical_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1997_l2015_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2016 fn c1998_l2016_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1998_l2016_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c1998_l2016_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1998_l2016_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c1998_l2016_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2017 fn c1999_l2017_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c1999_l2017_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c1999_l2017_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c1999_l2017_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c1999_l2017_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2018 fn c2000_l2018_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2000_l2018_assert_return_arithmetic_nan"); - let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2000_l2018_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2000_l2018_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "min", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2000_l2018_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -18467,7 +26062,10 @@ fn c2020_l2038_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2039 fn c2021_l2039_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2021_l2039_action_invoke"); - let result = instance.call("max", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "max", + &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -18475,7 +26073,10 @@ fn c2021_l2039_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2040 fn c2022_l2040_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2022_l2040_action_invoke"); - let result = instance.call("max", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "max", + &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -18483,7 +26084,10 @@ fn c2022_l2040_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2041 fn c2023_l2041_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2023_l2041_action_invoke"); - let result = instance.call("max", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "max", + &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -18491,7 +26095,10 @@ fn c2023_l2041_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2042 fn c2024_l2042_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2024_l2042_action_invoke"); - let result = instance.call("max", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "max", + &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -18531,7 +26138,10 @@ fn c2028_l2046_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2047 fn c2029_l2047_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2029_l2047_action_invoke"); - let result = instance.call("max", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -18547,7 +26157,10 @@ fn c2030_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2049 fn c2031_l2049_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2031_l2049_action_invoke"); - let result = instance.call("max", &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -18562,89 +26175,185 @@ fn c2032_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2051 fn c2033_l2051_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2033_l2051_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2033_l2051_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2033_l2051_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c2033_l2051_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2052 fn c2034_l2052_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2034_l2052_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2034_l2052_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2034_l2052_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c2034_l2052_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2053 fn c2035_l2053_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2035_l2053_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2035_l2053_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2035_l2053_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c2035_l2053_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2054 fn c2036_l2054_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2036_l2054_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2036_l2054_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2036_l2054_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2036_l2054_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2055 fn c2037_l2055_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2037_l2055_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2037_l2055_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2037_l2055_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c2037_l2055_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2056 fn c2038_l2056_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2038_l2056_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2038_l2056_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2038_l2056_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c2038_l2056_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2057 fn c2039_l2057_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2039_l2057_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2039_l2057_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2039_l2057_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c2039_l2057_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2058 fn c2040_l2058_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2040_l2058_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2040_l2058_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2040_l2058_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2040_l2058_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -18906,89 +26615,113 @@ fn c2072_l2090_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2091 fn c2073_l2091_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2073_l2091_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2073_l2091_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2073_l2091_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2092 fn c2074_l2092_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2074_l2092_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2074_l2092_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2074_l2092_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2093 fn c2075_l2093_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2075_l2093_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2075_l2093_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2075_l2093_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2094 fn c2076_l2094_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2076_l2094_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2076_l2094_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2076_l2094_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2095 fn c2077_l2095_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2077_l2095_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2077_l2095_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2077_l2095_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2096 fn c2078_l2096_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2078_l2096_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2078_l2096_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2078_l2096_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2097 fn c2079_l2097_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2079_l2097_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2079_l2097_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2079_l2097_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2098 fn c2080_l2098_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2080_l2098_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2080_l2098_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2080_l2098_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -19250,89 +26983,113 @@ fn c2112_l2130_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2131 fn c2113_l2131_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2113_l2131_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2113_l2131_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2113_l2131_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2132 fn c2114_l2132_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2114_l2132_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2114_l2132_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2114_l2132_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2133 fn c2115_l2133_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2115_l2133_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2115_l2133_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2115_l2133_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2134 fn c2116_l2134_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2116_l2134_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2116_l2134_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2116_l2134_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2135 fn c2117_l2135_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2117_l2135_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2117_l2135_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2117_l2135_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2136 fn c2118_l2136_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2118_l2136_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2118_l2136_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2118_l2136_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2137 fn c2119_l2137_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2119_l2137_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2119_l2137_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2119_l2137_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2138 fn c2120_l2138_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2120_l2138_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2120_l2138_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2120_l2138_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -19499,7 +27256,10 @@ fn c2140_l2158_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2159 fn c2141_l2159_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2141_l2159_action_invoke"); - let result = instance.call("max", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "max", + &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.5f64))))); result.map(|_| ()) } @@ -19507,7 +27267,10 @@ fn c2141_l2159_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2160 fn c2142_l2160_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2142_l2160_action_invoke"); - let result = instance.call("max", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "max", + &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -19515,7 +27278,10 @@ fn c2142_l2160_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2161 fn c2143_l2161_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2143_l2161_action_invoke"); - let result = instance.call("max", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "max", + &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.5f64))))); result.map(|_| ()) } @@ -19523,7 +27289,10 @@ fn c2143_l2161_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2162 fn c2144_l2162_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2144_l2162_action_invoke"); - let result = instance.call("max", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "max", + &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -19563,7 +27332,10 @@ fn c2148_l2166_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2167 fn c2149_l2167_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2149_l2167_action_invoke"); - let result = instance.call("max", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((-0.5f64))))); result.map(|_| ()) } @@ -19579,7 +27351,10 @@ fn c2150_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2169 fn c2151_l2169_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2151_l2169_action_invoke"); - let result = instance.call("max", &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((0.5f64))))); result.map(|_| ()) } @@ -19594,89 +27369,185 @@ fn c2152_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2171 fn c2153_l2171_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2153_l2171_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2153_l2171_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2153_l2171_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c2153_l2171_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2172 fn c2154_l2172_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2154_l2172_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2154_l2172_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2154_l2172_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c2154_l2172_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2173 fn c2155_l2173_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2155_l2173_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2155_l2173_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2155_l2173_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c2155_l2173_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2174 fn c2156_l2174_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2156_l2174_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2156_l2174_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2156_l2174_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2156_l2174_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2175 fn c2157_l2175_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2157_l2175_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2157_l2175_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2157_l2175_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c2157_l2175_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2176 fn c2158_l2176_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2158_l2176_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2158_l2176_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2158_l2176_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c2158_l2176_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2177 fn c2159_l2177_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2159_l2177_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2159_l2177_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2159_l2177_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c2159_l2177_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2178 fn c2160_l2178_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2160_l2178_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2160_l2178_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2160_l2178_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2160_l2178_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -19843,7 +27714,10 @@ fn c2180_l2198_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2199 fn c2181_l2199_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2181_l2199_action_invoke"); - let result = instance.call("max", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "max", + &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -19851,7 +27725,10 @@ fn c2181_l2199_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2200 fn c2182_l2200_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2182_l2200_action_invoke"); - let result = instance.call("max", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "max", + &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -19859,7 +27736,10 @@ fn c2182_l2200_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2201 fn c2183_l2201_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2183_l2201_action_invoke"); - let result = instance.call("max", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "max", + &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -19867,7 +27747,10 @@ fn c2183_l2201_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2202 fn c2184_l2202_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2184_l2202_action_invoke"); - let result = instance.call("max", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "max", + &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -19907,7 +27790,10 @@ fn c2188_l2206_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2207 fn c2189_l2207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2189_l2207_action_invoke"); - let result = instance.call("max", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -19923,7 +27809,10 @@ fn c2190_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2209 fn c2191_l2209_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2191_l2209_action_invoke"); - let result = instance.call("max", &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -19938,96 +27827,195 @@ fn c2192_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2211 fn c2193_l2211_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2193_l2211_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2193_l2211_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2193_l2211_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c2193_l2211_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2212 fn c2194_l2212_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2194_l2212_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2194_l2212_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2194_l2212_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c2194_l2212_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2213 fn c2195_l2213_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2195_l2213_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2195_l2213_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2195_l2213_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c2195_l2213_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2214 fn c2196_l2214_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2196_l2214_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2196_l2214_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2196_l2214_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2196_l2214_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2215 fn c2197_l2215_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2197_l2215_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2197_l2215_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2197_l2215_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c2197_l2215_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2216 fn c2198_l2216_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2198_l2216_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2198_l2216_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2198_l2216_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c2198_l2216_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2217 fn c2199_l2217_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2199_l2217_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2199_l2217_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2199_l2217_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c2199_l2217_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2218 fn c2200_l2218_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2200_l2218_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2200_l2218_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2200_l2218_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2200_l2218_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2219 fn c2201_l2219_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2201_l2219_action_invoke"); - let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "max", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -20035,7 +28023,10 @@ fn c2201_l2219_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2220 fn c2202_l2220_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2202_l2220_action_invoke"); - let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "max", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -20043,7 +28034,10 @@ fn c2202_l2220_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2221 fn c2203_l2221_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2203_l2221_action_invoke"); - let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "max", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -20051,7 +28045,10 @@ fn c2203_l2221_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2222 fn c2204_l2222_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2204_l2222_action_invoke"); - let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "max", + &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -20123,7 +28120,10 @@ fn c2212_l2230_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2231 fn c2213_l2231_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2213_l2231_action_invoke"); - let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "max", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.5f64))))); result.map(|_| ()) } @@ -20131,7 +28131,10 @@ fn c2213_l2231_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2232 fn c2214_l2232_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2214_l2232_action_invoke"); - let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "max", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.5f64))))); result.map(|_| ()) } @@ -20139,7 +28142,10 @@ fn c2214_l2232_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2233 fn c2215_l2233_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2215_l2233_action_invoke"); - let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "max", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -20147,7 +28153,10 @@ fn c2215_l2233_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2234 fn c2216_l2234_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2216_l2234_action_invoke"); - let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "max", + &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -20155,7 +28164,10 @@ fn c2216_l2234_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2235 fn c2217_l2235_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2217_l2235_action_invoke"); - let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "max", + &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -20163,7 +28175,10 @@ fn c2217_l2235_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2236 fn c2218_l2236_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2218_l2236_action_invoke"); - let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "max", + &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -20171,7 +28186,10 @@ fn c2218_l2236_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2237 fn c2219_l2237_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2219_l2237_action_invoke"); - let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "max", + &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -20179,7 +28197,10 @@ fn c2219_l2237_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2238 fn c2220_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2220_l2238_action_invoke"); - let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "max", + &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -20187,7 +28208,13 @@ fn c2220_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2239 fn c2221_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2221_l2239_action_invoke"); - let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "max", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -20195,7 +28222,13 @@ fn c2221_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2240 fn c2222_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2222_l2240_action_invoke"); - let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "max", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -20203,7 +28236,13 @@ fn c2222_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2241 fn c2223_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2223_l2241_action_invoke"); - let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "max", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -20211,7 +28250,13 @@ fn c2223_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2242 fn c2224_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2224_l2242_action_invoke"); - let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "max", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -20251,7 +28296,13 @@ fn c2228_l2246_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2247 fn c2229_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2229_l2247_action_invoke"); - let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "max", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -20259,7 +28310,13 @@ fn c2229_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2248 fn c2230_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2230_l2248_action_invoke"); - let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "max", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -20267,7 +28324,13 @@ fn c2230_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2249 fn c2231_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2231_l2249_action_invoke"); - let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "max", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -20275,96 +28338,198 @@ fn c2231_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2250 fn c2232_l2250_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2232_l2250_action_invoke"); - let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "max", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } // Line 2251 fn c2233_l2251_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2233_l2251_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2233_l2251_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2233_l2251_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c2233_l2251_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2252 fn c2234_l2252_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2234_l2252_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2234_l2252_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2234_l2252_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c2234_l2252_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2253 fn c2235_l2253_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2235_l2253_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2235_l2253_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2235_l2253_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c2235_l2253_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2254 fn c2236_l2254_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2236_l2254_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2236_l2254_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2236_l2254_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2236_l2254_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2255 fn c2237_l2255_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2237_l2255_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2237_l2255_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2237_l2255_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c2237_l2255_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2256 fn c2238_l2256_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2238_l2256_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2238_l2256_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2238_l2256_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c2238_l2256_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2257 fn c2239_l2257_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2239_l2257_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2239_l2257_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2239_l2257_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c2239_l2257_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2258 fn c2240_l2258_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2240_l2258_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2240_l2258_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2240_l2258_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2240_l2258_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -20626,96 +28791,123 @@ fn c2272_l2290_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2291 fn c2273_l2291_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2273_l2291_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2273_l2291_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2273_l2291_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2292 fn c2274_l2292_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2274_l2292_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2274_l2292_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2274_l2292_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2293 fn c2275_l2293_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2275_l2293_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2275_l2293_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2275_l2293_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2294 fn c2276_l2294_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2276_l2294_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2276_l2294_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2276_l2294_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2295 fn c2277_l2295_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2277_l2295_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2277_l2295_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2277_l2295_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2296 fn c2278_l2296_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2278_l2296_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2278_l2296_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2278_l2296_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2297 fn c2279_l2297_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2279_l2297_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2279_l2297_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2279_l2297_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2298 fn c2280_l2298_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2280_l2298_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2280_l2298_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2280_l2298_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2299 fn c2281_l2299_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2281_l2299_action_invoke"); - let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]); + let result = instance.call( + "max", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -20723,7 +28915,10 @@ fn c2281_l2299_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2300 fn c2282_l2300_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2282_l2300_action_invoke"); - let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))]); + let result = instance.call( + "max", + &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -20811,7 +29006,10 @@ fn c2292_l2310_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2311 fn c2293_l2311_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2293_l2311_action_invoke"); - let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]); + let result = instance.call( + "max", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.5f64))))); result.map(|_| ()) } @@ -20819,7 +29017,10 @@ fn c2293_l2311_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2312 fn c2294_l2312_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2294_l2312_action_invoke"); - let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))]); + let result = instance.call( + "max", + &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.5f64))))); result.map(|_| ()) } @@ -20843,7 +29044,10 @@ fn c2296_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2315 fn c2297_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2297_l2315_action_invoke"); - let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]); + let result = instance.call( + "max", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -20851,7 +29055,10 @@ fn c2297_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2316 fn c2298_l2316_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2298_l2316_action_invoke"); - let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))]); + let result = instance.call( + "max", + &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -20875,7 +29082,13 @@ fn c2300_l2318_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2319 fn c2301_l2319_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2301_l2319_action_invoke"); - let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "max", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -20883,7 +29096,13 @@ fn c2301_l2319_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2320 fn c2302_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2302_l2320_action_invoke"); - let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "max", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -20891,7 +29110,13 @@ fn c2302_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2321 fn c2303_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2303_l2321_action_invoke"); - let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "max", + &[ + Value::F64(f64::INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -20899,7 +29124,13 @@ fn c2303_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2322 fn c2304_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2304_l2322_action_invoke"); - let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "max", + &[ + Value::F64(f64::INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -20939,7 +29170,10 @@ fn c2308_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2327 fn c2309_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2309_l2327_action_invoke"); - let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -20947,7 +29181,10 @@ fn c2309_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2328 fn c2310_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2310_l2328_action_invoke"); - let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "max", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -20955,7 +29192,10 @@ fn c2310_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2329 fn c2311_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2311_l2329_action_invoke"); - let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "max", + &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -20963,976 +29203,1819 @@ fn c2311_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2330 fn c2312_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2312_l2330_action_invoke"); - let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "max", + &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } // Line 2331 fn c2313_l2331_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2313_l2331_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2313_l2331_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2313_l2331_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c2313_l2331_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2332 fn c2314_l2332_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2314_l2332_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2314_l2332_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2314_l2332_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c2314_l2332_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2333 fn c2315_l2333_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2315_l2333_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2315_l2333_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2315_l2333_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c2315_l2333_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2334 fn c2316_l2334_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2316_l2334_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2316_l2334_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2316_l2334_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2316_l2334_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2335 fn c2317_l2335_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2317_l2335_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2317_l2335_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2317_l2335_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c2317_l2335_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2336 fn c2318_l2336_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2318_l2336_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2318_l2336_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2318_l2336_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c2318_l2336_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2337 fn c2319_l2337_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2319_l2337_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2319_l2337_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2319_l2337_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c2319_l2337_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2338 fn c2320_l2338_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2320_l2338_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2320_l2338_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2320_l2338_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2320_l2338_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2339 fn c2321_l2339_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2321_l2339_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c2321_l2339_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2321_l2339_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2321_l2339_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2340 fn c2322_l2340_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2322_l2340_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c2322_l2340_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2322_l2340_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2322_l2340_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2341 fn c2323_l2341_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2323_l2341_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c2323_l2341_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2323_l2341_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2323_l2341_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2342 fn c2324_l2342_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2324_l2342_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c2324_l2342_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2324_l2342_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2324_l2342_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2343 fn c2325_l2343_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2325_l2343_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c2325_l2343_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2325_l2343_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2325_l2343_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2344 fn c2326_l2344_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2326_l2344_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]).unwrap().expect("Missing result in c2326_l2344_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2326_l2344_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2326_l2344_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2345 fn c2327_l2345_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2327_l2345_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c2327_l2345_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2327_l2345_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2327_l2345_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2346 fn c2328_l2346_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2328_l2346_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]).unwrap().expect("Missing result in c2328_l2346_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2328_l2346_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2328_l2346_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2347 fn c2329_l2347_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2329_l2347_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2329_l2347_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2329_l2347_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2348 fn c2330_l2348_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2330_l2348_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2330_l2348_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2330_l2348_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2349 fn c2331_l2349_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2331_l2349_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2331_l2349_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2331_l2349_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2350 fn c2332_l2350_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2332_l2350_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2332_l2350_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2332_l2350_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2351 fn c2333_l2351_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2333_l2351_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2333_l2351_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2333_l2351_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2352 fn c2334_l2352_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2334_l2352_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2334_l2352_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2334_l2352_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2353 fn c2335_l2353_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2335_l2353_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2335_l2353_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2335_l2353_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2354 fn c2336_l2354_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2336_l2354_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2336_l2354_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2336_l2354_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2355 fn c2337_l2355_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2337_l2355_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2337_l2355_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2337_l2355_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2356 fn c2338_l2356_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2338_l2356_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2338_l2356_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2338_l2356_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2357 fn c2339_l2357_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2339_l2357_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2339_l2357_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2339_l2357_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2358 fn c2340_l2358_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2340_l2358_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2340_l2358_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2340_l2358_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2359 fn c2341_l2359_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2341_l2359_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2341_l2359_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2341_l2359_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2360 fn c2342_l2360_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2342_l2360_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2342_l2360_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2342_l2360_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2361 fn c2343_l2361_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2343_l2361_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2343_l2361_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2343_l2361_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2362 fn c2344_l2362_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2344_l2362_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2344_l2362_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2344_l2362_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2363 fn c2345_l2363_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2345_l2363_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c2345_l2363_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2345_l2363_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c2345_l2363_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2364 fn c2346_l2364_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2346_l2364_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c2346_l2364_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2346_l2364_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c2346_l2364_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2365 fn c2347_l2365_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2347_l2365_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c2347_l2365_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2347_l2365_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c2347_l2365_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2366 fn c2348_l2366_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2348_l2366_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c2348_l2366_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2348_l2366_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c2348_l2366_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2367 fn c2349_l2367_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2349_l2367_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c2349_l2367_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2349_l2367_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c2349_l2367_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2368 fn c2350_l2368_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2350_l2368_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]).unwrap().expect("Missing result in c2350_l2368_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2350_l2368_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c2350_l2368_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2369 fn c2351_l2369_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2351_l2369_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c2351_l2369_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2351_l2369_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c2351_l2369_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2370 fn c2352_l2370_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2352_l2370_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]).unwrap().expect("Missing result in c2352_l2370_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2352_l2370_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.5f64)), + ], + ) + .unwrap() + .expect("Missing result in c2352_l2370_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2371 fn c2353_l2371_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2353_l2371_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c2353_l2371_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2353_l2371_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2353_l2371_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2372 fn c2354_l2372_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2354_l2372_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c2354_l2372_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2354_l2372_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2354_l2372_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2373 fn c2355_l2373_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2355_l2373_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c2355_l2373_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2355_l2373_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2355_l2373_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2374 fn c2356_l2374_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2356_l2374_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c2356_l2374_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2356_l2374_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2356_l2374_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2375 fn c2357_l2375_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2357_l2375_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c2357_l2375_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2357_l2375_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2357_l2375_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2376 fn c2358_l2376_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2358_l2376_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]).unwrap().expect("Missing result in c2358_l2376_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2358_l2376_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2358_l2376_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2377 fn c2359_l2377_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2359_l2377_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c2359_l2377_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2359_l2377_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2359_l2377_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2378 fn c2360_l2378_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2360_l2378_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]).unwrap().expect("Missing result in c2360_l2378_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2360_l2378_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((1.0f64)), + ], + ) + .unwrap() + .expect("Missing result in c2360_l2378_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2379 fn c2361_l2379_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2361_l2379_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c2361_l2379_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2361_l2379_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c2361_l2379_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2380 fn c2362_l2380_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2362_l2380_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c2362_l2380_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2362_l2380_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c2362_l2380_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2381 fn c2363_l2381_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2363_l2381_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c2363_l2381_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2363_l2381_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c2363_l2381_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2382 fn c2364_l2382_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2364_l2382_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c2364_l2382_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2364_l2382_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c2364_l2382_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2383 fn c2365_l2383_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2365_l2383_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c2365_l2383_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2365_l2383_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c2365_l2383_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2384 fn c2366_l2384_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2366_l2384_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c2366_l2384_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2366_l2384_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c2366_l2384_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2385 fn c2367_l2385_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2367_l2385_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c2367_l2385_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2367_l2385_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c2367_l2385_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2386 fn c2368_l2386_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2368_l2386_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]).unwrap().expect("Missing result in c2368_l2386_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2368_l2386_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((6.283185307179586f64)), + ], + ) + .unwrap() + .expect("Missing result in c2368_l2386_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2387 fn c2369_l2387_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2369_l2387_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2369_l2387_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2369_l2387_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2388 fn c2370_l2388_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2370_l2388_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2370_l2388_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2370_l2388_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2389 fn c2371_l2389_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2371_l2389_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2371_l2389_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2371_l2389_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2390 fn c2372_l2390_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2372_l2390_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2372_l2390_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2372_l2390_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2391 fn c2373_l2391_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2373_l2391_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2373_l2391_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2373_l2391_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2392 fn c2374_l2392_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2374_l2392_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2374_l2392_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2374_l2392_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2393 fn c2375_l2393_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2375_l2393_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2375_l2393_assert_return_canonical_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2375_l2393_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2394 fn c2376_l2394_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2376_l2394_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2376_l2394_assert_return_arithmetic_nan" + ); let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2376_l2394_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2395 fn c2377_l2395_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2377_l2395_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c2377_l2395_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2377_l2395_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2377_l2395_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2396 fn c2378_l2396_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2378_l2396_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c2378_l2396_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2378_l2396_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2378_l2396_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2397 fn c2379_l2397_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2379_l2397_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c2379_l2397_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2379_l2397_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2379_l2397_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2398 fn c2380_l2398_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2380_l2398_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c2380_l2398_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2380_l2398_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2380_l2398_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2399 fn c2381_l2399_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2381_l2399_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c2381_l2399_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2381_l2399_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2381_l2399_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2400 fn c2382_l2400_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2382_l2400_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c2382_l2400_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2382_l2400_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::NEG_INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2382_l2400_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2401 fn c2383_l2401_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2383_l2401_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c2383_l2401_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2383_l2401_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2383_l2401_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2402 fn c2384_l2402_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2384_l2402_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c2384_l2402_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2384_l2402_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::INFINITY), + ], + ) + .unwrap() + .expect("Missing result in c2384_l2402_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2403 fn c2385_l2403_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2385_l2403_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2385_l2403_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2385_l2403_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c2385_l2403_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2404 fn c2386_l2404_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2386_l2404_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2386_l2404_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2386_l2404_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c2386_l2404_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2405 fn c2387_l2405_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2387_l2405_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2387_l2405_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2387_l2405_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c2387_l2405_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2406 fn c2388_l2406_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2388_l2406_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2388_l2406_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2388_l2406_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c2388_l2406_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2407 fn c2389_l2407_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2389_l2407_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2389_l2407_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2389_l2407_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c2389_l2407_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2408 fn c2390_l2408_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2390_l2408_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2390_l2408_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2390_l2408_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c2390_l2408_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2409 fn c2391_l2409_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2391_l2409_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2391_l2409_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2391_l2409_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2391_l2409_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2410 fn c2392_l2410_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2392_l2410_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2392_l2410_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2392_l2410_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2392_l2410_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2411 fn c2393_l2411_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2393_l2411_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2393_l2411_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2393_l2411_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c2393_l2411_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2412 fn c2394_l2412_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2394_l2412_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2394_l2412_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2394_l2412_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ) + .unwrap() + .expect("Missing result in c2394_l2412_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2413 fn c2395_l2413_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2395_l2413_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2395_l2413_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2395_l2413_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c2395_l2413_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2414 fn c2396_l2414_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2396_l2414_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2396_l2414_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2396_l2414_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ) + .unwrap() + .expect("Missing result in c2396_l2414_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2415 fn c2397_l2415_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2397_l2415_assert_return_canonical_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2397_l2415_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2397_l2415_assert_return_canonical_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c2397_l2415_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2416 fn c2398_l2416_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2398_l2416_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2398_l2416_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2398_l2416_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ) + .unwrap() + .expect("Missing result in c2398_l2416_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2417 fn c2399_l2417_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2399_l2417_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2399_l2417_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2399_l2417_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2399_l2417_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2418 fn c2400_l2418_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2400_l2418_assert_return_arithmetic_nan"); - let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2400_l2418_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2400_l2418_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "max", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ) + .unwrap() + .expect("Missing result in c2400_l2418_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -21954,12 +31037,15 @@ fn c2402_l2420_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2421 fn c2403_l2421_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2403_l2421_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2403_l2421_assert_return_canonical_nan" + ); let result = instance.call("sqrt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]).unwrap().expect("Missing result in c2403_l2421_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -21973,12 +31059,15 @@ fn c2404_l2422_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2423 fn c2405_l2423_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2405_l2423_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2405_l2423_assert_return_canonical_nan" + ); let result = instance.call("sqrt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]).unwrap().expect("Missing result in c2405_l2423_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -21992,12 +31081,18 @@ fn c2406_l2424_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2425 fn c2407_l2425_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2407_l2425_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F64((-0.5f64))]).unwrap().expect("Missing result in c2407_l2425_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2407_l2425_assert_return_canonical_nan" + ); + let result = instance + .call("sqrt", &[Value::F64((-0.5f64))]) + .unwrap() + .expect("Missing result in c2407_l2425_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22011,12 +31106,18 @@ fn c2408_l2426_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2427 fn c2409_l2427_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2409_l2427_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F64((-1.0f64))]).unwrap().expect("Missing result in c2409_l2427_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2409_l2427_assert_return_canonical_nan" + ); + let result = instance + .call("sqrt", &[Value::F64((-1.0f64))]) + .unwrap() + .expect("Missing result in c2409_l2427_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22030,12 +31131,18 @@ fn c2410_l2428_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2429 fn c2411_l2429_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2411_l2429_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F64((-6.283185307179586f64))]).unwrap().expect("Missing result in c2411_l2429_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2411_l2429_assert_return_canonical_nan" + ); + let result = instance + .call("sqrt", &[Value::F64((-6.283185307179586f64))]) + .unwrap() + .expect("Missing result in c2411_l2429_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22049,12 +31156,15 @@ fn c2412_l2430_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2431 fn c2413_l2431_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2413_l2431_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2413_l2431_assert_return_canonical_nan" + ); let result = instance.call("sqrt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]).unwrap().expect("Missing result in c2413_l2431_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22068,12 +31178,18 @@ fn c2414_l2432_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2433 fn c2415_l2433_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2415_l2433_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c2415_l2433_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2415_l2433_assert_return_canonical_nan" + ); + let result = instance + .call("sqrt", &[Value::F64(f64::NEG_INFINITY)]) + .unwrap() + .expect("Missing result in c2415_l2433_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22087,45 +31203,69 @@ fn c2416_l2434_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2435 fn c2417_l2435_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2417_l2435_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2417_l2435_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2417_l2435_assert_return_canonical_nan" + ); + let result = instance + .call("sqrt", &[Value::F64(f64::from_bits(18444492273895866368))]) + .unwrap() + .expect("Missing result in c2417_l2435_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2436 fn c2418_l2436_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2418_l2436_assert_return_arithmetic_nan"); - let result = instance.call("sqrt", &[Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2418_l2436_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2418_l2436_assert_return_arithmetic_nan" + ); + let result = instance + .call("sqrt", &[Value::F64(f64::from_bits(18443366373989023744))]) + .unwrap() + .expect("Missing result in c2418_l2436_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2437 fn c2419_l2437_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2419_l2437_assert_return_canonical_nan"); - let result = instance.call("sqrt", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2419_l2437_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2419_l2437_assert_return_canonical_nan" + ); + let result = instance + .call("sqrt", &[Value::F64(f64::from_bits(9221120237041090560))]) + .unwrap() + .expect("Missing result in c2419_l2437_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2438 fn c2420_l2438_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2420_l2438_assert_return_arithmetic_nan"); - let result = instance.call("sqrt", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2420_l2438_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2420_l2438_assert_return_arithmetic_nan" + ); + let result = instance + .call("sqrt", &[Value::F64(f64::from_bits(9219994337134247936))]) + .unwrap() + .expect("Missing result in c2420_l2438_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22259,45 +31399,69 @@ fn c2436_l2454_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2455 fn c2437_l2455_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2437_l2455_assert_return_canonical_nan"); - let result = instance.call("floor", &[Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2437_l2455_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2437_l2455_assert_return_canonical_nan" + ); + let result = instance + .call("floor", &[Value::F64(f64::from_bits(18444492273895866368))]) + .unwrap() + .expect("Missing result in c2437_l2455_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2456 fn c2438_l2456_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2438_l2456_assert_return_arithmetic_nan"); - let result = instance.call("floor", &[Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2438_l2456_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2438_l2456_assert_return_arithmetic_nan" + ); + let result = instance + .call("floor", &[Value::F64(f64::from_bits(18443366373989023744))]) + .unwrap() + .expect("Missing result in c2438_l2456_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2457 fn c2439_l2457_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2439_l2457_assert_return_canonical_nan"); - let result = instance.call("floor", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2439_l2457_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2439_l2457_assert_return_canonical_nan" + ); + let result = instance + .call("floor", &[Value::F64(f64::from_bits(9221120237041090560))]) + .unwrap() + .expect("Missing result in c2439_l2457_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2458 fn c2440_l2458_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2440_l2458_assert_return_arithmetic_nan"); - let result = instance.call("floor", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2440_l2458_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2440_l2458_assert_return_arithmetic_nan" + ); + let result = instance + .call("floor", &[Value::F64(f64::from_bits(9219994337134247936))]) + .unwrap() + .expect("Missing result in c2440_l2458_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22431,45 +31595,69 @@ fn c2456_l2474_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2475 fn c2457_l2475_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2457_l2475_assert_return_canonical_nan"); - let result = instance.call("ceil", &[Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2457_l2475_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2457_l2475_assert_return_canonical_nan" + ); + let result = instance + .call("ceil", &[Value::F64(f64::from_bits(18444492273895866368))]) + .unwrap() + .expect("Missing result in c2457_l2475_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2476 fn c2458_l2476_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2458_l2476_assert_return_arithmetic_nan"); - let result = instance.call("ceil", &[Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2458_l2476_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2458_l2476_assert_return_arithmetic_nan" + ); + let result = instance + .call("ceil", &[Value::F64(f64::from_bits(18443366373989023744))]) + .unwrap() + .expect("Missing result in c2458_l2476_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2477 fn c2459_l2477_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2459_l2477_assert_return_canonical_nan"); - let result = instance.call("ceil", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2459_l2477_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2459_l2477_assert_return_canonical_nan" + ); + let result = instance + .call("ceil", &[Value::F64(f64::from_bits(9221120237041090560))]) + .unwrap() + .expect("Missing result in c2459_l2477_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2478 fn c2460_l2478_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2460_l2478_assert_return_arithmetic_nan"); - let result = instance.call("ceil", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2460_l2478_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2460_l2478_assert_return_arithmetic_nan" + ); + let result = instance + .call("ceil", &[Value::F64(f64::from_bits(9219994337134247936))]) + .unwrap() + .expect("Missing result in c2460_l2478_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22603,45 +31791,69 @@ fn c2476_l2494_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2495 fn c2477_l2495_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2477_l2495_assert_return_canonical_nan"); - let result = instance.call("trunc", &[Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2477_l2495_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2477_l2495_assert_return_canonical_nan" + ); + let result = instance + .call("trunc", &[Value::F64(f64::from_bits(18444492273895866368))]) + .unwrap() + .expect("Missing result in c2477_l2495_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2496 fn c2478_l2496_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2478_l2496_assert_return_arithmetic_nan"); - let result = instance.call("trunc", &[Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2478_l2496_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2478_l2496_assert_return_arithmetic_nan" + ); + let result = instance + .call("trunc", &[Value::F64(f64::from_bits(18443366373989023744))]) + .unwrap() + .expect("Missing result in c2478_l2496_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2497 fn c2479_l2497_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2479_l2497_assert_return_canonical_nan"); - let result = instance.call("trunc", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2479_l2497_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2479_l2497_assert_return_canonical_nan" + ); + let result = instance + .call("trunc", &[Value::F64(f64::from_bits(9221120237041090560))]) + .unwrap() + .expect("Missing result in c2479_l2497_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2498 fn c2480_l2498_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2480_l2498_assert_return_arithmetic_nan"); - let result = instance.call("trunc", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2480_l2498_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2480_l2498_assert_return_arithmetic_nan" + ); + let result = instance + .call("trunc", &[Value::F64(f64::from_bits(9219994337134247936))]) + .unwrap() + .expect("Missing result in c2480_l2498_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -22775,45 +31987,81 @@ fn c2496_l2514_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2515 fn c2497_l2515_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2497_l2515_assert_return_canonical_nan"); - let result = instance.call("nearest", &[Value::F64(f64::from_bits(18444492273895866368))]).unwrap().expect("Missing result in c2497_l2515_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2497_l2515_assert_return_canonical_nan" + ); + let result = instance + .call( + "nearest", + &[Value::F64(f64::from_bits(18444492273895866368))], + ) + .unwrap() + .expect("Missing result in c2497_l2515_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2516 fn c2498_l2516_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2498_l2516_assert_return_arithmetic_nan"); - let result = instance.call("nearest", &[Value::F64(f64::from_bits(18443366373989023744))]).unwrap().expect("Missing result in c2498_l2516_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2498_l2516_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "nearest", + &[Value::F64(f64::from_bits(18443366373989023744))], + ) + .unwrap() + .expect("Missing result in c2498_l2516_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2517 fn c2499_l2517_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c2499_l2517_assert_return_canonical_nan"); - let result = instance.call("nearest", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c2499_l2517_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c2499_l2517_assert_return_canonical_nan" + ); + let result = instance + .call( + "nearest", + &[Value::F64(f64::from_bits(9221120237041090560))], + ) + .unwrap() + .expect("Missing result in c2499_l2517_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 2518 fn c2500_l2518_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c2500_l2518_assert_return_arithmetic_nan"); - let result = instance.call("nearest", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c2500_l2518_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c2500_l2518_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "nearest", + &[Value::F64(f64::from_bits(9219994337134247936))], + ) + .unwrap() + .expect("Missing result in c2500_l2518_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } diff --git a/lib/runtime/tests/spectests/f64_bitwise.rs b/lib/runtime/tests/spectests/f64_bitwise.rs index 7b79dc13d..79053a938 100644 --- a/lib/runtime/tests/spectests/f64_bitwise.rs +++ b/lib/runtime/tests/spectests/f64_bitwise.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 4 fn create_module_1() -> Box { @@ -38,8 +34,11 @@ fn create_module_1() -> Box { (export \"copysign\" (func 2))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -210,7 +209,10 @@ fn c20_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 30 fn c21_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c21_l30_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -218,7 +220,10 @@ fn c21_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 31 fn c22_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c22_l31_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -226,7 +231,10 @@ fn c22_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 32 fn c23_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c23_l32_action_invoke"); - let result = instance.call("copysign", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -234,7 +242,10 @@ fn c23_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 33 fn c24_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c24_l33_action_invoke"); - let result = instance.call("copysign", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -274,7 +285,10 @@ fn c28_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 38 fn c29_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c29_l38_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -282,7 +296,10 @@ fn c29_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 39 fn c30_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c30_l39_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-0.0f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64((-0.0f64)), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -290,7 +307,10 @@ fn c30_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 40 fn c31_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c31_l40_action_invoke"); - let result = instance.call("copysign", &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64((0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -298,7 +318,10 @@ fn c31_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 41 fn c32_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c32_l41_action_invoke"); - let result = instance.call("copysign", &[Value::F64((0.0f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64((0.0f64)), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -306,7 +329,13 @@ fn c32_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 42 fn c33_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c33_l42_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "copysign", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -314,7 +343,13 @@ fn c33_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 43 fn c34_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c34_l43_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "copysign", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -322,7 +357,13 @@ fn c34_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 44 fn c35_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c35_l44_action_invoke"); - let result = instance.call("copysign", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "copysign", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -330,7 +371,13 @@ fn c35_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 45 fn c36_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c36_l45_action_invoke"); - let result = instance.call("copysign", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "copysign", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -1074,7 +1121,10 @@ fn c128_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 138 fn c129_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c129_l138_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.5f64))))); result.map(|_| ()) } @@ -1082,7 +1132,10 @@ fn c129_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 139 fn c130_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c130_l139_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.5f64))))); result.map(|_| ()) } @@ -1090,7 +1143,10 @@ fn c130_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 140 fn c131_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c131_l140_action_invoke"); - let result = instance.call("copysign", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.5f64))))); result.map(|_| ()) } @@ -1098,7 +1154,10 @@ fn c131_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 141 fn c132_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c132_l141_action_invoke"); - let result = instance.call("copysign", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.5f64))))); result.map(|_| ()) } @@ -1138,7 +1197,10 @@ fn c136_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 146 fn c137_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c137_l146_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((-0.5f64))))); result.map(|_| ()) } @@ -1146,7 +1208,10 @@ fn c137_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 147 fn c138_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c138_l147_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-0.5f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64((-0.5f64)), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((0.5f64))))); result.map(|_| ()) } @@ -1154,7 +1219,10 @@ fn c138_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 148 fn c139_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c139_l148_action_invoke"); - let result = instance.call("copysign", &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64((0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((-0.5f64))))); result.map(|_| ()) } @@ -1162,7 +1230,10 @@ fn c139_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 149 fn c140_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c140_l149_action_invoke"); - let result = instance.call("copysign", &[Value::F64((0.5f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64((0.5f64)), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((0.5f64))))); result.map(|_| ()) } @@ -1170,7 +1241,13 @@ fn c140_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 150 fn c141_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c141_l150_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "copysign", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-0.5f64))))); result.map(|_| ()) } @@ -1178,7 +1255,13 @@ fn c141_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 151 fn c142_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c142_l151_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "copysign", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.5f64))))); result.map(|_| ()) } @@ -1186,7 +1269,13 @@ fn c142_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 152 fn c143_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c143_l152_action_invoke"); - let result = instance.call("copysign", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "copysign", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-0.5f64))))); result.map(|_| ()) } @@ -1194,7 +1283,13 @@ fn c143_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 153 fn c144_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c144_l153_action_invoke"); - let result = instance.call("copysign", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "copysign", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.5f64))))); result.map(|_| ()) } @@ -1362,7 +1457,10 @@ fn c164_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 174 fn c165_l174_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c165_l174_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -1370,7 +1468,10 @@ fn c165_l174_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 175 fn c166_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c166_l175_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -1378,7 +1479,10 @@ fn c166_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 176 fn c167_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c167_l176_action_invoke"); - let result = instance.call("copysign", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -1386,7 +1490,10 @@ fn c167_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 177 fn c168_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c168_l177_action_invoke"); - let result = instance.call("copysign", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -1426,7 +1533,10 @@ fn c172_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 182 fn c173_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c173_l182_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -1434,7 +1544,10 @@ fn c173_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 183 fn c174_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c174_l183_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-1.0f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64((-1.0f64)), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -1442,7 +1555,10 @@ fn c174_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 184 fn c175_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c175_l184_action_invoke"); - let result = instance.call("copysign", &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64((1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -1450,7 +1566,10 @@ fn c175_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 185 fn c176_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c176_l185_action_invoke"); - let result = instance.call("copysign", &[Value::F64((1.0f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64((1.0f64)), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -1458,7 +1577,13 @@ fn c176_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 186 fn c177_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c177_l186_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "copysign", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -1466,7 +1591,13 @@ fn c177_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 187 fn c178_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c178_l187_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "copysign", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -1474,7 +1605,13 @@ fn c178_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 188 fn c179_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c179_l188_action_invoke"); - let result = instance.call("copysign", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "copysign", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -1482,7 +1619,13 @@ fn c179_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 189 fn c180_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c180_l189_action_invoke"); - let result = instance.call("copysign", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "copysign", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -1490,7 +1633,10 @@ fn c180_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 190 fn c181_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c181_l190_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -1498,7 +1644,10 @@ fn c181_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 191 fn c182_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c182_l191_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -1506,7 +1655,10 @@ fn c182_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 192 fn c183_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c183_l192_action_invoke"); - let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -1514,7 +1666,10 @@ fn c183_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 193 fn c184_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c184_l193_action_invoke"); - let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -1586,7 +1741,10 @@ fn c192_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 202 fn c193_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c193_l202_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "copysign", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -1594,7 +1752,10 @@ fn c193_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 203 fn c194_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c194_l203_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "copysign", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -1602,7 +1763,10 @@ fn c194_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 204 fn c195_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c195_l204_action_invoke"); - let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "copysign", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -1610,7 +1774,10 @@ fn c195_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 205 fn c196_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c196_l205_action_invoke"); - let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "copysign", + &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -1618,7 +1785,10 @@ fn c196_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 206 fn c197_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c197_l206_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -1626,7 +1796,10 @@ fn c197_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 207 fn c198_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c198_l207_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -1634,7 +1807,10 @@ fn c198_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 208 fn c199_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c199_l208_action_invoke"); - let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -1642,7 +1818,10 @@ fn c199_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 209 fn c200_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c200_l209_action_invoke"); - let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -1650,7 +1829,13 @@ fn c200_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 210 fn c201_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c201_l210_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -1658,7 +1843,13 @@ fn c201_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 211 fn c202_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c202_l211_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -1666,7 +1857,13 @@ fn c202_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 212 fn c203_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c203_l212_action_invoke"); - let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -1674,7 +1871,13 @@ fn c203_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 213 fn c204_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c204_l213_action_invoke"); - let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -1714,7 +1917,13 @@ fn c208_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 218 fn c209_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c209_l218_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -1722,7 +1931,13 @@ fn c209_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 219 fn c210_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c210_l219_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "copysign", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -1730,7 +1945,13 @@ fn c210_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 220 fn c211_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c211_l220_action_invoke"); - let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -1738,7 +1959,13 @@ fn c211_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 221 fn c212_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c212_l221_action_invoke"); - let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "copysign", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -1746,7 +1973,13 @@ fn c212_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 222 fn c213_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c213_l222_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "copysign", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -1754,7 +1987,13 @@ fn c213_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 223 fn c214_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c214_l223_action_invoke"); - let result = instance.call("copysign", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "copysign", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -1762,7 +2001,13 @@ fn c214_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 224 fn c215_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c215_l224_action_invoke"); - let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "copysign", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64))))); result.map(|_| ()) } @@ -1770,7 +2015,13 @@ fn c215_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 225 fn c216_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c216_l225_action_invoke"); - let result = instance.call("copysign", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "copysign", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64))))); result.map(|_| ()) } @@ -2066,7 +2317,10 @@ fn c252_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 262 fn c253_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c253_l262_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2074,7 +2328,10 @@ fn c253_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 263 fn c254_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c254_l263_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64(f64::NEG_INFINITY), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2082,7 +2339,10 @@ fn c254_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 264 fn c255_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c255_l264_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((-0.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64(f64::INFINITY), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2090,7 +2350,10 @@ fn c255_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 265 fn c256_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c256_l265_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((0.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64(f64::INFINITY), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2162,7 +2425,10 @@ fn c264_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 274 fn c265_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c265_l274_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]); + let result = instance.call( + "copysign", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2170,7 +2436,10 @@ fn c265_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 275 fn c266_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c266_l275_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))]); + let result = instance.call( + "copysign", + &[Value::F64(f64::NEG_INFINITY), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2178,7 +2447,10 @@ fn c266_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 276 fn c267_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c267_l276_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((-0.5f64))]); + let result = instance.call( + "copysign", + &[Value::F64(f64::INFINITY), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2186,7 +2458,10 @@ fn c267_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 277 fn c268_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c268_l277_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((0.5f64))]); + let result = instance.call( + "copysign", + &[Value::F64(f64::INFINITY), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2194,7 +2469,10 @@ fn c268_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 278 fn c269_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c269_l278_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2202,7 +2480,10 @@ fn c269_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 279 fn c270_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c270_l279_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64(f64::NEG_INFINITY), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2210,7 +2491,10 @@ fn c270_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 280 fn c271_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c271_l280_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((-1.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64(f64::INFINITY), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2218,7 +2502,10 @@ fn c271_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 281 fn c272_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c272_l281_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((1.0f64))]); + let result = instance.call( + "copysign", + &[Value::F64(f64::INFINITY), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2226,7 +2513,13 @@ fn c272_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 282 fn c273_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c273_l282_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2234,7 +2527,13 @@ fn c273_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 283 fn c274_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c274_l283_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2242,7 +2541,13 @@ fn c274_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 284 fn c275_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c275_l284_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2250,7 +2555,13 @@ fn c275_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 285 fn c276_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c276_l285_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2290,7 +2601,10 @@ fn c280_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 290 fn c281_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c281_l290_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2298,7 +2612,10 @@ fn c281_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 291 fn c282_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c282_l291_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2306,7 +2623,10 @@ fn c282_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 292 fn c283_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c283_l292_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2314,7 +2634,10 @@ fn c283_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 293 fn c284_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c284_l293_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "copysign", + &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2322,7 +2645,13 @@ fn c284_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 294 fn c285_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c285_l294_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2330,7 +2659,13 @@ fn c285_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 295 fn c286_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c286_l295_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2338,7 +2673,13 @@ fn c286_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 296 fn c287_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c287_l296_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY)))); result.map(|_| ()) } @@ -2346,7 +2687,13 @@ fn c287_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 297 fn c288_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c288_l297_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY)))); result.map(|_| ()) } @@ -2354,56 +2701,92 @@ fn c288_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 298 fn c289_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c289_l298_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.0f64)), + ], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 299 fn c290_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c290_l299_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.0f64)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 300 fn c291_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c291_l300_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.0f64)), + ], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 301 fn c292_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c292_l301_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2412,12 +2795,15 @@ fn c293_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c293_l302_action_invoke"); let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2426,12 +2812,15 @@ fn c294_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c294_l303_action_invoke"); let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2440,12 +2829,15 @@ fn c295_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c295_l304_action_invoke"); let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2454,12 +2846,15 @@ fn c296_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c296_l305_action_invoke"); let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64))]); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2468,12 +2863,15 @@ fn c297_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c297_l306_action_invoke"); let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2482,12 +2880,15 @@ fn c298_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c298_l307_action_invoke"); let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2496,12 +2897,15 @@ fn c299_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c299_l308_action_invoke"); let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2510,180 +2914,291 @@ fn c300_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c300_l309_action_invoke"); let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64))]); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 310 fn c301_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c301_l310_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.5f64)), + ], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 311 fn c302_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c302_l311_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.5f64)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 312 fn c303_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c303_l312_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.5f64)), + ], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 313 fn c304_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c304_l313_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.5f64)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 314 fn c305_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c305_l314_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-1.0f64)), + ], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 315 fn c306_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c306_l315_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((1.0f64)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 316 fn c307_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c307_l316_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-1.0f64)), + ], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 317 fn c308_l317_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c308_l317_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 318 fn c309_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c309_l318_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-6.283185307179586f64)), + ], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 319 fn c310_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c310_l319_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((6.283185307179586f64)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 320 fn c311_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c311_l320_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-6.283185307179586f64)), + ], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 321 fn c312_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c312_l321_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((6.283185307179586f64)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2692,12 +3207,15 @@ fn c313_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c313_l322_action_invoke"); let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2706,12 +3224,15 @@ fn c314_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c314_l323_action_invoke"); let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2720,12 +3241,15 @@ fn c315_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c315_l324_action_invoke"); let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2734,124 +3258,199 @@ fn c316_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c316_l325_action_invoke"); let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 326 fn c317_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c317_l326_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::NEG_INFINITY), + ], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 327 fn c318_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c318_l327_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::INFINITY), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 328 fn c319_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c319_l328_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::NEG_INFINITY), + ], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 329 fn c320_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c320_l329_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::INFINITY), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 330 fn c321_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c321_l330_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 331 fn c322_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c322_l331_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 332 fn c323_l332_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c323_l332_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 333 fn c324_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c324_l333_action_invoke"); - let result = instance.call("copysign", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "copysign", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -2988,12 +3587,15 @@ fn c341_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c341_l350_action_invoke"); let result = instance.call("abs", &[Value::F64(f64::from_bits(18444492273895866368))]); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3002,12 +3604,15 @@ fn c342_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c342_l351_action_invoke"); let result = instance.call("abs", &[Value::F64(f64::from_bits(9221120237041090560))]); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3144,12 +3749,15 @@ fn c359_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c359_l368_action_invoke"); let result = instance.call("neg", &[Value::F64(f64::from_bits(18444492273895866368))]); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3158,12 +3766,15 @@ fn c360_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c360_l369_action_invoke"); let result = instance.call("neg", &[Value::F64(f64::from_bits(9221120237041090560))]); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } diff --git a/lib/runtime/tests/spectests/f64_cmp.rs b/lib/runtime/tests/spectests/f64_cmp.rs index 0478a3852..d643b902e 100644 --- a/lib/runtime/tests/spectests/f64_cmp.rs +++ b/lib/runtime/tests/spectests/f64_cmp.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 4 fn create_module_1() -> Box { @@ -54,8 +50,11 @@ fn create_module_1() -> Box { (export \"ge\" (func 5))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -226,7 +225,10 @@ fn c20_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 33 fn c21_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c21_l33_action_invoke"); - let result = instance.call("eq", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "eq", + &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -234,7 +236,10 @@ fn c21_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 34 fn c22_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c22_l34_action_invoke"); - let result = instance.call("eq", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "eq", + &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -242,7 +247,10 @@ fn c22_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 35 fn c23_l35_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c23_l35_action_invoke"); - let result = instance.call("eq", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "eq", + &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -250,7 +258,10 @@ fn c23_l35_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 36 fn c24_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c24_l36_action_invoke"); - let result = instance.call("eq", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "eq", + &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -290,7 +301,10 @@ fn c28_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 41 fn c29_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c29_l41_action_invoke"); - let result = instance.call("eq", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -322,7 +336,13 @@ fn c32_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 45 fn c33_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c33_l45_action_invoke"); - let result = instance.call("eq", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "eq", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -330,7 +350,13 @@ fn c33_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 46 fn c34_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c34_l46_action_invoke"); - let result = instance.call("eq", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "eq", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -338,7 +364,13 @@ fn c34_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 47 fn c35_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c35_l47_action_invoke"); - let result = instance.call("eq", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "eq", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -346,7 +378,13 @@ fn c35_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 48 fn c36_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c36_l48_action_invoke"); - let result = instance.call("eq", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "eq", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -354,7 +392,13 @@ fn c36_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 49 fn c37_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c37_l49_action_invoke"); - let result = instance.call("eq", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "eq", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -362,7 +406,13 @@ fn c37_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 50 fn c38_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c38_l50_action_invoke"); - let result = instance.call("eq", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "eq", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -370,7 +420,13 @@ fn c38_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 51 fn c39_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c39_l51_action_invoke"); - let result = instance.call("eq", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "eq", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -378,7 +434,13 @@ fn c39_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 52 fn c40_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c40_l52_action_invoke"); - let result = instance.call("eq", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "eq", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1186,7 +1248,10 @@ fn c140_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 153 fn c141_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c141_l153_action_invoke"); - let result = instance.call("eq", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "eq", + &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1194,7 +1259,10 @@ fn c141_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 154 fn c142_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c142_l154_action_invoke"); - let result = instance.call("eq", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "eq", + &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1202,7 +1270,10 @@ fn c142_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 155 fn c143_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c143_l155_action_invoke"); - let result = instance.call("eq", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "eq", + &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1210,7 +1281,10 @@ fn c143_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 156 fn c144_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c144_l156_action_invoke"); - let result = instance.call("eq", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "eq", + &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1250,7 +1324,10 @@ fn c148_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 161 fn c149_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c149_l161_action_invoke"); - let result = instance.call("eq", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1282,7 +1359,13 @@ fn c152_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 165 fn c153_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c153_l165_action_invoke"); - let result = instance.call("eq", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "eq", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1290,7 +1373,13 @@ fn c153_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 166 fn c154_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c154_l166_action_invoke"); - let result = instance.call("eq", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "eq", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1298,7 +1387,13 @@ fn c154_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 167 fn c155_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c155_l167_action_invoke"); - let result = instance.call("eq", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "eq", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1306,7 +1401,13 @@ fn c155_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 168 fn c156_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c156_l168_action_invoke"); - let result = instance.call("eq", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "eq", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1314,7 +1415,13 @@ fn c156_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 169 fn c157_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c157_l169_action_invoke"); - let result = instance.call("eq", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "eq", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1322,7 +1429,13 @@ fn c157_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 170 fn c158_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c158_l170_action_invoke"); - let result = instance.call("eq", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "eq", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1330,7 +1443,13 @@ fn c158_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 171 fn c159_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c159_l171_action_invoke"); - let result = instance.call("eq", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "eq", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1338,7 +1457,13 @@ fn c159_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 172 fn c160_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c160_l172_action_invoke"); - let result = instance.call("eq", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "eq", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1506,7 +1631,10 @@ fn c180_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 193 fn c181_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c181_l193_action_invoke"); - let result = instance.call("eq", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "eq", + &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1514,7 +1642,10 @@ fn c181_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 194 fn c182_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c182_l194_action_invoke"); - let result = instance.call("eq", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "eq", + &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1522,7 +1653,10 @@ fn c182_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 195 fn c183_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c183_l195_action_invoke"); - let result = instance.call("eq", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "eq", + &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1530,7 +1664,10 @@ fn c183_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 196 fn c184_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c184_l196_action_invoke"); - let result = instance.call("eq", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "eq", + &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1570,7 +1707,10 @@ fn c188_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 201 fn c189_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c189_l201_action_invoke"); - let result = instance.call("eq", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1602,7 +1742,13 @@ fn c192_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 205 fn c193_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c193_l205_action_invoke"); - let result = instance.call("eq", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "eq", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1610,7 +1756,13 @@ fn c193_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 206 fn c194_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c194_l206_action_invoke"); - let result = instance.call("eq", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "eq", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1618,7 +1770,13 @@ fn c194_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 207 fn c195_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c195_l207_action_invoke"); - let result = instance.call("eq", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "eq", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1626,7 +1784,13 @@ fn c195_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 208 fn c196_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c196_l208_action_invoke"); - let result = instance.call("eq", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "eq", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1634,7 +1798,13 @@ fn c196_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 209 fn c197_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c197_l209_action_invoke"); - let result = instance.call("eq", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "eq", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1642,7 +1812,13 @@ fn c197_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 210 fn c198_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c198_l210_action_invoke"); - let result = instance.call("eq", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "eq", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1650,7 +1826,13 @@ fn c198_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 211 fn c199_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c199_l211_action_invoke"); - let result = instance.call("eq", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "eq", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1658,7 +1840,13 @@ fn c199_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 212 fn c200_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c200_l212_action_invoke"); - let result = instance.call("eq", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "eq", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1666,7 +1854,10 @@ fn c200_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 213 fn c201_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c201_l213_action_invoke"); - let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "eq", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1674,7 +1865,10 @@ fn c201_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 214 fn c202_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c202_l214_action_invoke"); - let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "eq", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1682,7 +1876,10 @@ fn c202_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 215 fn c203_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c203_l215_action_invoke"); - let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "eq", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1690,7 +1887,10 @@ fn c203_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 216 fn c204_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c204_l216_action_invoke"); - let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "eq", + &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1762,7 +1962,10 @@ fn c212_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 225 fn c213_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c213_l225_action_invoke"); - let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "eq", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1770,7 +1973,10 @@ fn c213_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 226 fn c214_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c214_l226_action_invoke"); - let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "eq", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1778,7 +1984,10 @@ fn c214_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 227 fn c215_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c215_l227_action_invoke"); - let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "eq", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1786,7 +1995,10 @@ fn c215_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 228 fn c216_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c216_l228_action_invoke"); - let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "eq", + &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1794,7 +2006,10 @@ fn c216_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 229 fn c217_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c217_l229_action_invoke"); - let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "eq", + &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1802,7 +2017,10 @@ fn c217_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 230 fn c218_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c218_l230_action_invoke"); - let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "eq", + &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1810,7 +2028,10 @@ fn c218_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 231 fn c219_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c219_l231_action_invoke"); - let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "eq", + &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1818,7 +2039,10 @@ fn c219_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 232 fn c220_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c220_l232_action_invoke"); - let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "eq", + &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1826,7 +2050,13 @@ fn c220_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 233 fn c221_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c221_l233_action_invoke"); - let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1834,7 +2064,13 @@ fn c221_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 234 fn c222_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c222_l234_action_invoke"); - let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1842,7 +2078,13 @@ fn c222_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 235 fn c223_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c223_l235_action_invoke"); - let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1850,7 +2092,13 @@ fn c223_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 236 fn c224_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c224_l236_action_invoke"); - let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1890,7 +2138,13 @@ fn c228_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 241 fn c229_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c229_l241_action_invoke"); - let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1898,7 +2152,13 @@ fn c229_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 242 fn c230_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c230_l242_action_invoke"); - let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1906,7 +2166,13 @@ fn c230_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 243 fn c231_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c231_l243_action_invoke"); - let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1914,7 +2180,13 @@ fn c231_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 244 fn c232_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c232_l244_action_invoke"); - let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1922,7 +2194,13 @@ fn c232_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 245 fn c233_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c233_l245_action_invoke"); - let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "eq", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1930,7 +2208,13 @@ fn c233_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 246 fn c234_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c234_l246_action_invoke"); - let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "eq", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1938,7 +2222,13 @@ fn c234_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 247 fn c235_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c235_l247_action_invoke"); - let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "eq", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1946,7 +2236,13 @@ fn c235_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 248 fn c236_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c236_l248_action_invoke"); - let result = instance.call("eq", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "eq", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1954,7 +2250,13 @@ fn c236_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 249 fn c237_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c237_l249_action_invoke"); - let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "eq", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1962,7 +2264,13 @@ fn c237_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 250 fn c238_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c238_l250_action_invoke"); - let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "eq", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1970,7 +2278,13 @@ fn c238_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 251 fn c239_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c239_l251_action_invoke"); - let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "eq", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1978,7 +2292,13 @@ fn c239_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 252 fn c240_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c240_l252_action_invoke"); - let result = instance.call("eq", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "eq", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2306,7 +2626,10 @@ fn c280_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 293 fn c281_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c281_l293_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]); + let result = instance.call( + "eq", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2402,7 +2725,10 @@ fn c292_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 305 fn c293_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c293_l305_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]); + let result = instance.call( + "eq", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2434,7 +2760,10 @@ fn c296_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 309 fn c297_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c297_l309_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]); + let result = instance.call( + "eq", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2466,7 +2795,13 @@ fn c300_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 313 fn c301_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c301_l313_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2474,7 +2809,13 @@ fn c301_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 314 fn c302_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c302_l314_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2482,7 +2823,13 @@ fn c302_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 315 fn c303_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c303_l315_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2490,7 +2837,13 @@ fn c303_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 316 fn c304_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c304_l316_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2530,7 +2883,10 @@ fn c308_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 321 fn c309_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c309_l321_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2538,7 +2894,10 @@ fn c309_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 322 fn c310_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c310_l322_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "eq", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2546,7 +2905,10 @@ fn c310_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 323 fn c311_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c311_l323_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2554,7 +2916,10 @@ fn c311_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 324 fn c312_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c312_l324_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "eq", + &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2562,7 +2927,13 @@ fn c312_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 325 fn c313_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c313_l325_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2570,7 +2941,13 @@ fn c313_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 326 fn c314_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c314_l326_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2578,7 +2955,13 @@ fn c314_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 327 fn c315_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c315_l327_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2586,7 +2969,13 @@ fn c315_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 328 fn c316_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c316_l328_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2594,7 +2983,13 @@ fn c316_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 329 fn c317_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c317_l329_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2602,7 +2997,13 @@ fn c317_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 330 fn c318_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c318_l330_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2610,7 +3011,13 @@ fn c318_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 331 fn c319_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c319_l331_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2618,7 +3025,13 @@ fn c319_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 332 fn c320_l332_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c320_l332_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2626,7 +3039,13 @@ fn c320_l332_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 333 fn c321_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c321_l333_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2634,7 +3053,13 @@ fn c321_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 334 fn c322_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c322_l334_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2642,7 +3067,13 @@ fn c322_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 335 fn c323_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c323_l335_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2650,7 +3081,13 @@ fn c323_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 336 fn c324_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c324_l336_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2658,7 +3095,13 @@ fn c324_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 337 fn c325_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c325_l337_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2666,7 +3109,13 @@ fn c325_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 338 fn c326_l338_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c326_l338_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2674,7 +3123,13 @@ fn c326_l338_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 339 fn c327_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c327_l339_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2682,7 +3137,13 @@ fn c327_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 340 fn c328_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c328_l340_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2818,7 +3279,13 @@ fn c344_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 357 fn c345_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c345_l357_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2826,7 +3293,13 @@ fn c345_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 358 fn c346_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c346_l358_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2834,7 +3307,13 @@ fn c346_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 359 fn c347_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c347_l359_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2842,7 +3321,13 @@ fn c347_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 360 fn c348_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c348_l360_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2850,7 +3335,13 @@ fn c348_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 361 fn c349_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c349_l361_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2858,7 +3349,13 @@ fn c349_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 362 fn c350_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c350_l362_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2866,7 +3363,13 @@ fn c350_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 363 fn c351_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c351_l363_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2874,7 +3377,13 @@ fn c351_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 364 fn c352_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c352_l364_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2882,7 +3391,13 @@ fn c352_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 365 fn c353_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c353_l365_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2890,7 +3405,13 @@ fn c353_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 366 fn c354_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c354_l366_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2898,7 +3419,13 @@ fn c354_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 367 fn c355_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c355_l367_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2906,7 +3433,13 @@ fn c355_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 368 fn c356_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c356_l368_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2914,7 +3447,13 @@ fn c356_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 369 fn c357_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c357_l369_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2922,7 +3461,13 @@ fn c357_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 370 fn c358_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c358_l370_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2930,7 +3475,13 @@ fn c358_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 371 fn c359_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c359_l371_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2938,7 +3489,13 @@ fn c359_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 372 fn c360_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c360_l372_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2946,7 +3503,13 @@ fn c360_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 373 fn c361_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c361_l373_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2954,7 +3517,13 @@ fn c361_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 374 fn c362_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c362_l374_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2962,7 +3531,13 @@ fn c362_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 375 fn c363_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c363_l375_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2970,7 +3545,13 @@ fn c363_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 376 fn c364_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c364_l376_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2978,7 +3559,13 @@ fn c364_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 377 fn c365_l377_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c365_l377_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2986,7 +3573,13 @@ fn c365_l377_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 378 fn c366_l378_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c366_l378_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2994,7 +3587,13 @@ fn c366_l378_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 379 fn c367_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c367_l379_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3002,7 +3601,13 @@ fn c367_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 380 fn c368_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c368_l380_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3074,7 +3679,13 @@ fn c376_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 389 fn c377_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c377_l389_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3082,7 +3693,13 @@ fn c377_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 390 fn c378_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c378_l390_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3090,7 +3707,13 @@ fn c378_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 391 fn c379_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c379_l391_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3098,7 +3721,13 @@ fn c379_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 392 fn c380_l392_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c380_l392_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3106,7 +3735,13 @@ fn c380_l392_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 393 fn c381_l393_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c381_l393_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3114,7 +3749,13 @@ fn c381_l393_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 394 fn c382_l394_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c382_l394_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3122,7 +3763,13 @@ fn c382_l394_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 395 fn c383_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c383_l395_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3130,7 +3777,13 @@ fn c383_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 396 fn c384_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c384_l396_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3138,7 +3791,13 @@ fn c384_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 397 fn c385_l397_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c385_l397_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3146,7 +3805,13 @@ fn c385_l397_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 398 fn c386_l398_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c386_l398_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3154,7 +3819,13 @@ fn c386_l398_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 399 fn c387_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c387_l399_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3162,7 +3833,13 @@ fn c387_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 400 fn c388_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c388_l400_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3170,7 +3847,13 @@ fn c388_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 401 fn c389_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c389_l401_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3178,7 +3861,13 @@ fn c389_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 402 fn c390_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c390_l402_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3186,7 +3875,13 @@ fn c390_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 403 fn c391_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c391_l403_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3194,7 +3889,13 @@ fn c391_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 404 fn c392_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c392_l404_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3202,7 +3903,13 @@ fn c392_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 405 fn c393_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c393_l405_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3210,7 +3917,13 @@ fn c393_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 406 fn c394_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c394_l406_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3218,7 +3931,13 @@ fn c394_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 407 fn c395_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c395_l407_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3226,7 +3945,13 @@ fn c395_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 408 fn c396_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c396_l408_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3234,7 +3959,13 @@ fn c396_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 409 fn c397_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c397_l409_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3242,7 +3973,13 @@ fn c397_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 410 fn c398_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c398_l410_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3250,7 +3987,13 @@ fn c398_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 411 fn c399_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c399_l411_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3258,7 +4001,13 @@ fn c399_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 412 fn c400_l412_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c400_l412_action_invoke"); - let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "eq", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3426,7 +4175,10 @@ fn c420_l432_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 433 fn c421_l433_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c421_l433_action_invoke"); - let result = instance.call("ne", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ne", + &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3434,7 +4186,10 @@ fn c421_l433_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 434 fn c422_l434_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c422_l434_action_invoke"); - let result = instance.call("ne", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ne", + &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3442,7 +4197,10 @@ fn c422_l434_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 435 fn c423_l435_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c423_l435_action_invoke"); - let result = instance.call("ne", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ne", + &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3450,7 +4208,10 @@ fn c423_l435_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 436 fn c424_l436_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c424_l436_action_invoke"); - let result = instance.call("ne", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ne", + &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3490,7 +4251,10 @@ fn c428_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 441 fn c429_l441_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c429_l441_action_invoke"); - let result = instance.call("ne", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3522,7 +4286,13 @@ fn c432_l444_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 445 fn c433_l445_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c433_l445_action_invoke"); - let result = instance.call("ne", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ne", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3530,7 +4300,13 @@ fn c433_l445_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 446 fn c434_l446_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c434_l446_action_invoke"); - let result = instance.call("ne", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ne", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3538,7 +4314,13 @@ fn c434_l446_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 447 fn c435_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c435_l447_action_invoke"); - let result = instance.call("ne", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ne", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3546,7 +4328,13 @@ fn c435_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 448 fn c436_l448_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c436_l448_action_invoke"); - let result = instance.call("ne", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ne", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3554,7 +4342,13 @@ fn c436_l448_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 449 fn c437_l449_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c437_l449_action_invoke"); - let result = instance.call("ne", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ne", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3562,7 +4356,13 @@ fn c437_l449_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 450 fn c438_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c438_l450_action_invoke"); - let result = instance.call("ne", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ne", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3570,7 +4370,13 @@ fn c438_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 451 fn c439_l451_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c439_l451_action_invoke"); - let result = instance.call("ne", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ne", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3578,7 +4384,13 @@ fn c439_l451_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 452 fn c440_l452_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c440_l452_action_invoke"); - let result = instance.call("ne", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ne", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4386,7 +5198,10 @@ fn c540_l552_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 553 fn c541_l553_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c541_l553_action_invoke"); - let result = instance.call("ne", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ne", + &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4394,7 +5209,10 @@ fn c541_l553_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 554 fn c542_l554_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c542_l554_action_invoke"); - let result = instance.call("ne", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ne", + &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4402,7 +5220,10 @@ fn c542_l554_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 555 fn c543_l555_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c543_l555_action_invoke"); - let result = instance.call("ne", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ne", + &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4410,7 +5231,10 @@ fn c543_l555_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 556 fn c544_l556_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c544_l556_action_invoke"); - let result = instance.call("ne", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ne", + &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4450,7 +5274,10 @@ fn c548_l560_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 561 fn c549_l561_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c549_l561_action_invoke"); - let result = instance.call("ne", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4482,7 +5309,13 @@ fn c552_l564_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 565 fn c553_l565_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c553_l565_action_invoke"); - let result = instance.call("ne", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ne", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4490,7 +5323,13 @@ fn c553_l565_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 566 fn c554_l566_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c554_l566_action_invoke"); - let result = instance.call("ne", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ne", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4498,7 +5337,13 @@ fn c554_l566_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 567 fn c555_l567_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c555_l567_action_invoke"); - let result = instance.call("ne", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ne", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4506,7 +5351,13 @@ fn c555_l567_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 568 fn c556_l568_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c556_l568_action_invoke"); - let result = instance.call("ne", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ne", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4514,7 +5365,13 @@ fn c556_l568_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 569 fn c557_l569_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c557_l569_action_invoke"); - let result = instance.call("ne", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ne", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4522,7 +5379,13 @@ fn c557_l569_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 570 fn c558_l570_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c558_l570_action_invoke"); - let result = instance.call("ne", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ne", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4530,7 +5393,13 @@ fn c558_l570_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 571 fn c559_l571_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c559_l571_action_invoke"); - let result = instance.call("ne", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ne", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4538,7 +5407,13 @@ fn c559_l571_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 572 fn c560_l572_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c560_l572_action_invoke"); - let result = instance.call("ne", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ne", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4706,7 +5581,10 @@ fn c580_l592_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 593 fn c581_l593_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c581_l593_action_invoke"); - let result = instance.call("ne", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ne", + &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4714,7 +5592,10 @@ fn c581_l593_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 594 fn c582_l594_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c582_l594_action_invoke"); - let result = instance.call("ne", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ne", + &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4722,7 +5603,10 @@ fn c582_l594_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 595 fn c583_l595_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c583_l595_action_invoke"); - let result = instance.call("ne", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ne", + &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4730,7 +5614,10 @@ fn c583_l595_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 596 fn c584_l596_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c584_l596_action_invoke"); - let result = instance.call("ne", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ne", + &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4770,7 +5657,10 @@ fn c588_l600_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 601 fn c589_l601_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c589_l601_action_invoke"); - let result = instance.call("ne", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4802,7 +5692,13 @@ fn c592_l604_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 605 fn c593_l605_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c593_l605_action_invoke"); - let result = instance.call("ne", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ne", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4810,7 +5706,13 @@ fn c593_l605_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 606 fn c594_l606_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c594_l606_action_invoke"); - let result = instance.call("ne", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ne", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4818,7 +5720,13 @@ fn c594_l606_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 607 fn c595_l607_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c595_l607_action_invoke"); - let result = instance.call("ne", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ne", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4826,7 +5734,13 @@ fn c595_l607_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 608 fn c596_l608_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c596_l608_action_invoke"); - let result = instance.call("ne", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ne", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4834,7 +5748,13 @@ fn c596_l608_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 609 fn c597_l609_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c597_l609_action_invoke"); - let result = instance.call("ne", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ne", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4842,7 +5762,13 @@ fn c597_l609_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 610 fn c598_l610_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c598_l610_action_invoke"); - let result = instance.call("ne", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ne", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4850,7 +5776,13 @@ fn c598_l610_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 611 fn c599_l611_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c599_l611_action_invoke"); - let result = instance.call("ne", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ne", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4858,7 +5790,13 @@ fn c599_l611_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 612 fn c600_l612_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c600_l612_action_invoke"); - let result = instance.call("ne", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ne", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4866,7 +5804,10 @@ fn c600_l612_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 613 fn c601_l613_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c601_l613_action_invoke"); - let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "ne", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4874,7 +5815,10 @@ fn c601_l613_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 614 fn c602_l614_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c602_l614_action_invoke"); - let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "ne", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4882,7 +5826,10 @@ fn c602_l614_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 615 fn c603_l615_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c603_l615_action_invoke"); - let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "ne", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4890,7 +5837,10 @@ fn c603_l615_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 616 fn c604_l616_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c604_l616_action_invoke"); - let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "ne", + &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4962,7 +5912,10 @@ fn c612_l624_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 625 fn c613_l625_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c613_l625_action_invoke"); - let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "ne", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4970,7 +5923,10 @@ fn c613_l625_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 626 fn c614_l626_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c614_l626_action_invoke"); - let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "ne", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4978,7 +5934,10 @@ fn c614_l626_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 627 fn c615_l627_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c615_l627_action_invoke"); - let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "ne", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4986,7 +5945,10 @@ fn c615_l627_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 628 fn c616_l628_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c616_l628_action_invoke"); - let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "ne", + &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4994,7 +5956,10 @@ fn c616_l628_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 629 fn c617_l629_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c617_l629_action_invoke"); - let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "ne", + &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5002,7 +5967,10 @@ fn c617_l629_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 630 fn c618_l630_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c618_l630_action_invoke"); - let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "ne", + &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5010,7 +5978,10 @@ fn c618_l630_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 631 fn c619_l631_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c619_l631_action_invoke"); - let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "ne", + &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5018,7 +5989,10 @@ fn c619_l631_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 632 fn c620_l632_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c620_l632_action_invoke"); - let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "ne", + &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5026,7 +6000,13 @@ fn c620_l632_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 633 fn c621_l633_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c621_l633_action_invoke"); - let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -5034,7 +6014,13 @@ fn c621_l633_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 634 fn c622_l634_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c622_l634_action_invoke"); - let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5042,7 +6028,13 @@ fn c622_l634_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 635 fn c623_l635_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c623_l635_action_invoke"); - let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5050,7 +6042,13 @@ fn c623_l635_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 636 fn c624_l636_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c624_l636_action_invoke"); - let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -5090,7 +6088,13 @@ fn c628_l640_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 641 fn c629_l641_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c629_l641_action_invoke"); - let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5098,7 +6102,13 @@ fn c629_l641_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 642 fn c630_l642_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c630_l642_action_invoke"); - let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5106,7 +6116,13 @@ fn c630_l642_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 643 fn c631_l643_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c631_l643_action_invoke"); - let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5114,7 +6130,13 @@ fn c631_l643_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 644 fn c632_l644_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c632_l644_action_invoke"); - let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5122,7 +6144,13 @@ fn c632_l644_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 645 fn c633_l645_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c633_l645_action_invoke"); - let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ne", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5130,7 +6158,13 @@ fn c633_l645_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 646 fn c634_l646_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c634_l646_action_invoke"); - let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ne", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5138,7 +6172,13 @@ fn c634_l646_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 647 fn c635_l647_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c635_l647_action_invoke"); - let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ne", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5146,7 +6186,13 @@ fn c635_l647_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 648 fn c636_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c636_l648_action_invoke"); - let result = instance.call("ne", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ne", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5154,7 +6200,13 @@ fn c636_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 649 fn c637_l649_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c637_l649_action_invoke"); - let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ne", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5162,7 +6214,13 @@ fn c637_l649_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 650 fn c638_l650_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c638_l650_action_invoke"); - let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ne", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5170,7 +6228,13 @@ fn c638_l650_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 651 fn c639_l651_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c639_l651_action_invoke"); - let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ne", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5178,7 +6242,13 @@ fn c639_l651_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 652 fn c640_l652_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c640_l652_action_invoke"); - let result = instance.call("ne", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ne", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5506,7 +6576,10 @@ fn c680_l692_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 693 fn c681_l693_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c681_l693_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]); + let result = instance.call( + "ne", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5602,7 +6675,10 @@ fn c692_l704_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 705 fn c693_l705_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c693_l705_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]); + let result = instance.call( + "ne", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5634,7 +6710,10 @@ fn c696_l708_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 709 fn c697_l709_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c697_l709_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]); + let result = instance.call( + "ne", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5666,7 +6745,13 @@ fn c700_l712_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 713 fn c701_l713_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c701_l713_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5674,7 +6759,13 @@ fn c701_l713_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 714 fn c702_l714_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c702_l714_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5682,7 +6773,13 @@ fn c702_l714_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 715 fn c703_l715_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c703_l715_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5690,7 +6787,13 @@ fn c703_l715_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 716 fn c704_l716_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c704_l716_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5730,7 +6833,10 @@ fn c708_l720_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 721 fn c709_l721_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c709_l721_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -5738,7 +6844,10 @@ fn c709_l721_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 722 fn c710_l722_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c710_l722_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ne", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5746,7 +6855,10 @@ fn c710_l722_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 723 fn c711_l723_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c711_l723_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5754,7 +6866,10 @@ fn c711_l723_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 724 fn c712_l724_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c712_l724_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ne", + &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -5762,7 +6877,13 @@ fn c712_l724_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 725 fn c713_l725_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c713_l725_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5770,7 +6891,13 @@ fn c713_l725_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 726 fn c714_l726_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c714_l726_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5778,7 +6905,13 @@ fn c714_l726_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 727 fn c715_l727_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c715_l727_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5786,7 +6919,13 @@ fn c715_l727_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 728 fn c716_l728_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c716_l728_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5794,7 +6933,13 @@ fn c716_l728_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 729 fn c717_l729_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c717_l729_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5802,7 +6947,13 @@ fn c717_l729_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 730 fn c718_l730_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c718_l730_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5810,7 +6961,13 @@ fn c718_l730_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 731 fn c719_l731_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c719_l731_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5818,7 +6975,13 @@ fn c719_l731_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 732 fn c720_l732_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c720_l732_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5826,7 +6989,13 @@ fn c720_l732_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 733 fn c721_l733_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c721_l733_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5834,7 +7003,13 @@ fn c721_l733_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 734 fn c722_l734_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c722_l734_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5842,7 +7017,13 @@ fn c722_l734_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 735 fn c723_l735_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c723_l735_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5850,7 +7031,13 @@ fn c723_l735_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 736 fn c724_l736_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c724_l736_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5858,7 +7045,13 @@ fn c724_l736_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 737 fn c725_l737_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c725_l737_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5866,7 +7059,13 @@ fn c725_l737_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 738 fn c726_l738_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c726_l738_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5874,7 +7073,13 @@ fn c726_l738_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 739 fn c727_l739_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c727_l739_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5882,7 +7087,13 @@ fn c727_l739_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 740 fn c728_l740_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c728_l740_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6018,7 +7229,13 @@ fn c744_l756_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 757 fn c745_l757_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c745_l757_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6026,7 +7243,13 @@ fn c745_l757_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 758 fn c746_l758_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c746_l758_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6034,7 +7257,13 @@ fn c746_l758_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 759 fn c747_l759_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c747_l759_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6042,7 +7271,13 @@ fn c747_l759_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 760 fn c748_l760_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c748_l760_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6050,7 +7285,13 @@ fn c748_l760_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 761 fn c749_l761_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c749_l761_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6058,7 +7299,13 @@ fn c749_l761_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 762 fn c750_l762_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c750_l762_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6066,7 +7313,13 @@ fn c750_l762_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 763 fn c751_l763_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c751_l763_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6074,7 +7327,13 @@ fn c751_l763_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 764 fn c752_l764_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c752_l764_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6082,7 +7341,13 @@ fn c752_l764_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 765 fn c753_l765_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c753_l765_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6090,7 +7355,13 @@ fn c753_l765_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 766 fn c754_l766_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c754_l766_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6098,7 +7369,13 @@ fn c754_l766_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 767 fn c755_l767_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c755_l767_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6106,7 +7383,13 @@ fn c755_l767_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 768 fn c756_l768_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c756_l768_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6114,7 +7397,13 @@ fn c756_l768_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 769 fn c757_l769_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c757_l769_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6122,7 +7411,13 @@ fn c757_l769_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 770 fn c758_l770_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c758_l770_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6130,7 +7425,13 @@ fn c758_l770_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 771 fn c759_l771_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c759_l771_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6138,7 +7439,13 @@ fn c759_l771_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 772 fn c760_l772_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c760_l772_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6146,7 +7453,13 @@ fn c760_l772_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 773 fn c761_l773_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c761_l773_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6154,7 +7467,13 @@ fn c761_l773_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 774 fn c762_l774_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c762_l774_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6162,7 +7481,13 @@ fn c762_l774_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 775 fn c763_l775_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c763_l775_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6170,7 +7495,13 @@ fn c763_l775_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 776 fn c764_l776_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c764_l776_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6178,7 +7509,13 @@ fn c764_l776_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 777 fn c765_l777_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c765_l777_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6186,7 +7523,13 @@ fn c765_l777_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 778 fn c766_l778_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c766_l778_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6194,7 +7537,13 @@ fn c766_l778_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 779 fn c767_l779_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c767_l779_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6202,7 +7551,13 @@ fn c767_l779_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 780 fn c768_l780_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c768_l780_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6274,7 +7629,13 @@ fn c776_l788_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 789 fn c777_l789_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c777_l789_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6282,7 +7643,13 @@ fn c777_l789_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 790 fn c778_l790_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c778_l790_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6290,7 +7657,13 @@ fn c778_l790_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 791 fn c779_l791_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c779_l791_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6298,7 +7671,13 @@ fn c779_l791_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 792 fn c780_l792_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c780_l792_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6306,7 +7685,13 @@ fn c780_l792_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 793 fn c781_l793_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c781_l793_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6314,7 +7699,13 @@ fn c781_l793_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 794 fn c782_l794_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c782_l794_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6322,7 +7713,13 @@ fn c782_l794_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 795 fn c783_l795_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c783_l795_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6330,7 +7727,13 @@ fn c783_l795_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 796 fn c784_l796_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c784_l796_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6338,7 +7741,13 @@ fn c784_l796_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 797 fn c785_l797_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c785_l797_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6346,7 +7755,13 @@ fn c785_l797_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 798 fn c786_l798_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c786_l798_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6354,7 +7769,13 @@ fn c786_l798_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 799 fn c787_l799_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c787_l799_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6362,7 +7783,13 @@ fn c787_l799_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 800 fn c788_l800_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c788_l800_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6370,7 +7797,13 @@ fn c788_l800_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 801 fn c789_l801_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c789_l801_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6378,7 +7811,13 @@ fn c789_l801_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 802 fn c790_l802_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c790_l802_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6386,7 +7825,13 @@ fn c790_l802_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 803 fn c791_l803_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c791_l803_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6394,7 +7839,13 @@ fn c791_l803_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 804 fn c792_l804_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c792_l804_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6402,7 +7853,13 @@ fn c792_l804_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 805 fn c793_l805_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c793_l805_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6410,7 +7867,13 @@ fn c793_l805_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 806 fn c794_l806_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c794_l806_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6418,7 +7881,13 @@ fn c794_l806_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 807 fn c795_l807_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c795_l807_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6426,7 +7895,13 @@ fn c795_l807_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 808 fn c796_l808_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c796_l808_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6434,7 +7909,13 @@ fn c796_l808_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 809 fn c797_l809_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c797_l809_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6442,7 +7923,13 @@ fn c797_l809_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 810 fn c798_l810_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c798_l810_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6450,7 +7937,13 @@ fn c798_l810_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 811 fn c799_l811_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c799_l811_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6458,7 +7951,13 @@ fn c799_l811_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 812 fn c800_l812_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c800_l812_action_invoke"); - let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ne", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6626,7 +8125,10 @@ fn c820_l832_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 833 fn c821_l833_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c821_l833_action_invoke"); - let result = instance.call("lt", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "lt", + &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6634,7 +8136,10 @@ fn c821_l833_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 834 fn c822_l834_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c822_l834_action_invoke"); - let result = instance.call("lt", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "lt", + &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6642,7 +8147,10 @@ fn c822_l834_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 835 fn c823_l835_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c823_l835_action_invoke"); - let result = instance.call("lt", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "lt", + &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6650,7 +8158,10 @@ fn c823_l835_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 836 fn c824_l836_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c824_l836_action_invoke"); - let result = instance.call("lt", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "lt", + &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -6690,7 +8201,10 @@ fn c828_l840_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 841 fn c829_l841_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c829_l841_action_invoke"); - let result = instance.call("lt", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6722,7 +8236,13 @@ fn c832_l844_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 845 fn c833_l845_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c833_l845_action_invoke"); - let result = instance.call("lt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "lt", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6730,7 +8250,13 @@ fn c833_l845_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 846 fn c834_l846_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c834_l846_action_invoke"); - let result = instance.call("lt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "lt", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6738,7 +8264,13 @@ fn c834_l846_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 847 fn c835_l847_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c835_l847_action_invoke"); - let result = instance.call("lt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "lt", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6746,7 +8278,13 @@ fn c835_l847_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 848 fn c836_l848_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c836_l848_action_invoke"); - let result = instance.call("lt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "lt", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6754,7 +8292,13 @@ fn c836_l848_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 849 fn c837_l849_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c837_l849_action_invoke"); - let result = instance.call("lt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "lt", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6762,7 +8306,13 @@ fn c837_l849_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 850 fn c838_l850_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c838_l850_action_invoke"); - let result = instance.call("lt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "lt", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6770,7 +8320,13 @@ fn c838_l850_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 851 fn c839_l851_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c839_l851_action_invoke"); - let result = instance.call("lt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "lt", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -6778,7 +8334,13 @@ fn c839_l851_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 852 fn c840_l852_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c840_l852_action_invoke"); - let result = instance.call("lt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "lt", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7586,7 +9148,10 @@ fn c940_l952_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 953 fn c941_l953_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c941_l953_action_invoke"); - let result = instance.call("lt", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "lt", + &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7594,7 +9159,10 @@ fn c941_l953_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 954 fn c942_l954_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c942_l954_action_invoke"); - let result = instance.call("lt", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "lt", + &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7602,7 +9170,10 @@ fn c942_l954_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 955 fn c943_l955_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c943_l955_action_invoke"); - let result = instance.call("lt", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "lt", + &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7610,7 +9181,10 @@ fn c943_l955_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 956 fn c944_l956_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c944_l956_action_invoke"); - let result = instance.call("lt", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "lt", + &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7650,7 +9224,10 @@ fn c948_l960_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 961 fn c949_l961_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c949_l961_action_invoke"); - let result = instance.call("lt", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7682,7 +9259,13 @@ fn c952_l964_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 965 fn c953_l965_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c953_l965_action_invoke"); - let result = instance.call("lt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "lt", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7690,7 +9273,13 @@ fn c953_l965_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 966 fn c954_l966_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c954_l966_action_invoke"); - let result = instance.call("lt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "lt", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7698,7 +9287,13 @@ fn c954_l966_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 967 fn c955_l967_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c955_l967_action_invoke"); - let result = instance.call("lt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "lt", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7706,7 +9301,13 @@ fn c955_l967_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 968 fn c956_l968_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c956_l968_action_invoke"); - let result = instance.call("lt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "lt", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7714,7 +9315,13 @@ fn c956_l968_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 969 fn c957_l969_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c957_l969_action_invoke"); - let result = instance.call("lt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "lt", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7722,7 +9329,13 @@ fn c957_l969_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 970 fn c958_l970_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c958_l970_action_invoke"); - let result = instance.call("lt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "lt", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7730,7 +9343,13 @@ fn c958_l970_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 971 fn c959_l971_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c959_l971_action_invoke"); - let result = instance.call("lt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "lt", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7738,7 +9357,13 @@ fn c959_l971_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 972 fn c960_l972_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c960_l972_action_invoke"); - let result = instance.call("lt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "lt", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7906,7 +9531,10 @@ fn c980_l992_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 993 fn c981_l993_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c981_l993_action_invoke"); - let result = instance.call("lt", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "lt", + &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7914,7 +9542,10 @@ fn c981_l993_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 994 fn c982_l994_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c982_l994_action_invoke"); - let result = instance.call("lt", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "lt", + &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7922,7 +9553,10 @@ fn c982_l994_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 995 fn c983_l995_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c983_l995_action_invoke"); - let result = instance.call("lt", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "lt", + &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -7930,7 +9564,10 @@ fn c983_l995_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 996 fn c984_l996_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c984_l996_action_invoke"); - let result = instance.call("lt", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "lt", + &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -7970,7 +9607,10 @@ fn c988_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1001 fn c989_l1001_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c989_l1001_action_invoke"); - let result = instance.call("lt", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8002,7 +9642,13 @@ fn c992_l1004_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1005 fn c993_l1005_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c993_l1005_action_invoke"); - let result = instance.call("lt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "lt", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8010,7 +9656,13 @@ fn c993_l1005_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1006 fn c994_l1006_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c994_l1006_action_invoke"); - let result = instance.call("lt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "lt", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8018,7 +9670,13 @@ fn c994_l1006_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1007 fn c995_l1007_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c995_l1007_action_invoke"); - let result = instance.call("lt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "lt", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8026,7 +9684,13 @@ fn c995_l1007_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1008 fn c996_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c996_l1008_action_invoke"); - let result = instance.call("lt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "lt", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8034,7 +9698,13 @@ fn c996_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1009 fn c997_l1009_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c997_l1009_action_invoke"); - let result = instance.call("lt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "lt", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8042,7 +9712,13 @@ fn c997_l1009_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1010 fn c998_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c998_l1010_action_invoke"); - let result = instance.call("lt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "lt", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8050,7 +9726,13 @@ fn c998_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1011 fn c999_l1011_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c999_l1011_action_invoke"); - let result = instance.call("lt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "lt", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8058,7 +9740,13 @@ fn c999_l1011_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1012 fn c1000_l1012_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1000_l1012_action_invoke"); - let result = instance.call("lt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "lt", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8066,7 +9754,10 @@ fn c1000_l1012_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1013 fn c1001_l1013_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1001_l1013_action_invoke"); - let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "lt", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8074,7 +9765,10 @@ fn c1001_l1013_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1014 fn c1002_l1014_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1002_l1014_action_invoke"); - let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "lt", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8082,7 +9776,10 @@ fn c1002_l1014_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1015 fn c1003_l1015_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1003_l1015_action_invoke"); - let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "lt", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8090,7 +9787,10 @@ fn c1003_l1015_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1016 fn c1004_l1016_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1004_l1016_action_invoke"); - let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "lt", + &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8162,7 +9862,10 @@ fn c1012_l1024_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1025 fn c1013_l1025_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1013_l1025_action_invoke"); - let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "lt", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8170,7 +9873,10 @@ fn c1013_l1025_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1026 fn c1014_l1026_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1014_l1026_action_invoke"); - let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "lt", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8178,7 +9884,10 @@ fn c1014_l1026_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1027 fn c1015_l1027_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1015_l1027_action_invoke"); - let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "lt", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8186,7 +9895,10 @@ fn c1015_l1027_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1028 fn c1016_l1028_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1016_l1028_action_invoke"); - let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "lt", + &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8194,7 +9906,10 @@ fn c1016_l1028_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1029 fn c1017_l1029_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1017_l1029_action_invoke"); - let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "lt", + &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8202,7 +9917,10 @@ fn c1017_l1029_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1030 fn c1018_l1030_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1018_l1030_action_invoke"); - let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "lt", + &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8210,7 +9928,10 @@ fn c1018_l1030_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1031 fn c1019_l1031_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1019_l1031_action_invoke"); - let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "lt", + &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8218,7 +9939,10 @@ fn c1019_l1031_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1032 fn c1020_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1020_l1032_action_invoke"); - let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "lt", + &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8226,7 +9950,13 @@ fn c1020_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1033 fn c1021_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1021_l1033_action_invoke"); - let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8234,7 +9964,13 @@ fn c1021_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1034 fn c1022_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1022_l1034_action_invoke"); - let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8242,7 +9978,13 @@ fn c1022_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1035 fn c1023_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1023_l1035_action_invoke"); - let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8250,7 +9992,13 @@ fn c1023_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1036 fn c1024_l1036_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1024_l1036_action_invoke"); - let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8290,7 +10038,13 @@ fn c1028_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1041 fn c1029_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1029_l1041_action_invoke"); - let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8298,7 +10052,13 @@ fn c1029_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1042 fn c1030_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1030_l1042_action_invoke"); - let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8306,7 +10066,13 @@ fn c1030_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1043 fn c1031_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1031_l1043_action_invoke"); - let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8314,7 +10080,13 @@ fn c1031_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1044 fn c1032_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1032_l1044_action_invoke"); - let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8322,7 +10094,13 @@ fn c1032_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1045 fn c1033_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1033_l1045_action_invoke"); - let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "lt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8330,7 +10108,13 @@ fn c1033_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1046 fn c1034_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1034_l1046_action_invoke"); - let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "lt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8338,7 +10122,13 @@ fn c1034_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1047 fn c1035_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1035_l1047_action_invoke"); - let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "lt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8346,7 +10136,13 @@ fn c1035_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1048 fn c1036_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1036_l1048_action_invoke"); - let result = instance.call("lt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "lt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8354,7 +10150,13 @@ fn c1036_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1049 fn c1037_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1037_l1049_action_invoke"); - let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "lt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8362,7 +10164,13 @@ fn c1037_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1050 fn c1038_l1050_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1038_l1050_action_invoke"); - let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "lt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8370,7 +10178,13 @@ fn c1038_l1050_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1051 fn c1039_l1051_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1039_l1051_action_invoke"); - let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "lt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8378,7 +10192,13 @@ fn c1039_l1051_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1052 fn c1040_l1052_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1040_l1052_action_invoke"); - let result = instance.call("lt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "lt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8706,7 +10526,10 @@ fn c1080_l1092_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1093 fn c1081_l1093_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1081_l1093_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]); + let result = instance.call( + "lt", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8802,7 +10625,10 @@ fn c1092_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1105 fn c1093_l1105_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1093_l1105_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]); + let result = instance.call( + "lt", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8834,7 +10660,10 @@ fn c1096_l1108_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1109 fn c1097_l1109_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1097_l1109_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]); + let result = instance.call( + "lt", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8866,7 +10695,13 @@ fn c1100_l1112_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1113 fn c1101_l1113_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1101_l1113_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8874,7 +10709,13 @@ fn c1101_l1113_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1114 fn c1102_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1102_l1114_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8882,7 +10723,13 @@ fn c1102_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1115 fn c1103_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1103_l1115_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8890,7 +10737,13 @@ fn c1103_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1116 fn c1104_l1116_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1104_l1116_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8930,7 +10783,10 @@ fn c1108_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1121 fn c1109_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1109_l1121_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8938,7 +10794,10 @@ fn c1109_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1122 fn c1110_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1110_l1122_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "lt", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -8946,7 +10805,10 @@ fn c1110_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1123 fn c1111_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1111_l1123_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8954,7 +10816,10 @@ fn c1111_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1124 fn c1112_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1112_l1124_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "lt", + &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8962,7 +10827,13 @@ fn c1112_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1125 fn c1113_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1113_l1125_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8970,7 +10841,13 @@ fn c1113_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1126 fn c1114_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1114_l1126_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8978,7 +10855,13 @@ fn c1114_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1127 fn c1115_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1115_l1127_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8986,7 +10869,13 @@ fn c1115_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1128 fn c1116_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1116_l1128_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -8994,7 +10883,13 @@ fn c1116_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1129 fn c1117_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1117_l1129_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9002,7 +10897,13 @@ fn c1117_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1130 fn c1118_l1130_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1118_l1130_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9010,7 +10911,13 @@ fn c1118_l1130_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1131 fn c1119_l1131_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1119_l1131_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9018,7 +10925,13 @@ fn c1119_l1131_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1132 fn c1120_l1132_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1120_l1132_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9026,7 +10939,13 @@ fn c1120_l1132_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1133 fn c1121_l1133_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1121_l1133_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9034,7 +10953,13 @@ fn c1121_l1133_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1134 fn c1122_l1134_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1122_l1134_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9042,7 +10967,13 @@ fn c1122_l1134_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1135 fn c1123_l1135_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1123_l1135_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9050,7 +10981,13 @@ fn c1123_l1135_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1136 fn c1124_l1136_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1124_l1136_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9058,7 +10995,13 @@ fn c1124_l1136_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1137 fn c1125_l1137_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1125_l1137_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9066,7 +11009,13 @@ fn c1125_l1137_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1138 fn c1126_l1138_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1126_l1138_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9074,7 +11023,13 @@ fn c1126_l1138_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1139 fn c1127_l1139_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1127_l1139_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9082,7 +11037,13 @@ fn c1127_l1139_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1140 fn c1128_l1140_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1128_l1140_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9218,7 +11179,13 @@ fn c1144_l1156_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1157 fn c1145_l1157_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1145_l1157_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9226,7 +11193,13 @@ fn c1145_l1157_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1158 fn c1146_l1158_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1146_l1158_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9234,7 +11207,13 @@ fn c1146_l1158_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1159 fn c1147_l1159_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1147_l1159_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9242,7 +11221,13 @@ fn c1147_l1159_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1160 fn c1148_l1160_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1148_l1160_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9250,7 +11235,13 @@ fn c1148_l1160_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1161 fn c1149_l1161_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1149_l1161_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9258,7 +11249,13 @@ fn c1149_l1161_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1162 fn c1150_l1162_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1150_l1162_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9266,7 +11263,13 @@ fn c1150_l1162_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1163 fn c1151_l1163_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1151_l1163_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9274,7 +11277,13 @@ fn c1151_l1163_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1164 fn c1152_l1164_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1152_l1164_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9282,7 +11291,13 @@ fn c1152_l1164_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1165 fn c1153_l1165_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1153_l1165_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9290,7 +11305,13 @@ fn c1153_l1165_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1166 fn c1154_l1166_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1154_l1166_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9298,7 +11319,13 @@ fn c1154_l1166_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1167 fn c1155_l1167_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1155_l1167_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9306,7 +11333,13 @@ fn c1155_l1167_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1168 fn c1156_l1168_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1156_l1168_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9314,7 +11347,13 @@ fn c1156_l1168_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1169 fn c1157_l1169_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1157_l1169_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9322,7 +11361,13 @@ fn c1157_l1169_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1170 fn c1158_l1170_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1158_l1170_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9330,7 +11375,13 @@ fn c1158_l1170_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1171 fn c1159_l1171_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1159_l1171_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9338,7 +11389,13 @@ fn c1159_l1171_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1172 fn c1160_l1172_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1160_l1172_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9346,7 +11403,13 @@ fn c1160_l1172_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1173 fn c1161_l1173_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1161_l1173_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9354,7 +11417,13 @@ fn c1161_l1173_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1174 fn c1162_l1174_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1162_l1174_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9362,7 +11431,13 @@ fn c1162_l1174_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1175 fn c1163_l1175_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1163_l1175_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9370,7 +11445,13 @@ fn c1163_l1175_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1176 fn c1164_l1176_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1164_l1176_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9378,7 +11459,13 @@ fn c1164_l1176_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1177 fn c1165_l1177_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1165_l1177_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9386,7 +11473,13 @@ fn c1165_l1177_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1178 fn c1166_l1178_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1166_l1178_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9394,7 +11487,13 @@ fn c1166_l1178_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1179 fn c1167_l1179_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1167_l1179_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9402,7 +11501,13 @@ fn c1167_l1179_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1180 fn c1168_l1180_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1168_l1180_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9474,7 +11579,13 @@ fn c1176_l1188_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1189 fn c1177_l1189_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1177_l1189_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9482,7 +11593,13 @@ fn c1177_l1189_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1190 fn c1178_l1190_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1178_l1190_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9490,7 +11607,13 @@ fn c1178_l1190_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1191 fn c1179_l1191_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1179_l1191_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9498,7 +11621,13 @@ fn c1179_l1191_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1192 fn c1180_l1192_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1180_l1192_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9506,7 +11635,13 @@ fn c1180_l1192_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1193 fn c1181_l1193_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1181_l1193_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9514,7 +11649,13 @@ fn c1181_l1193_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1194 fn c1182_l1194_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1182_l1194_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9522,7 +11663,13 @@ fn c1182_l1194_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1195 fn c1183_l1195_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1183_l1195_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9530,7 +11677,13 @@ fn c1183_l1195_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1196 fn c1184_l1196_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1184_l1196_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9538,7 +11691,13 @@ fn c1184_l1196_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1197 fn c1185_l1197_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1185_l1197_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9546,7 +11705,13 @@ fn c1185_l1197_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1198 fn c1186_l1198_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1186_l1198_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9554,7 +11719,13 @@ fn c1186_l1198_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1199 fn c1187_l1199_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1187_l1199_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9562,7 +11733,13 @@ fn c1187_l1199_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1200 fn c1188_l1200_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1188_l1200_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9570,7 +11747,13 @@ fn c1188_l1200_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1201 fn c1189_l1201_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1189_l1201_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9578,7 +11761,13 @@ fn c1189_l1201_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1202 fn c1190_l1202_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1190_l1202_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9586,7 +11775,13 @@ fn c1190_l1202_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1203 fn c1191_l1203_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1191_l1203_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9594,7 +11789,13 @@ fn c1191_l1203_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1204 fn c1192_l1204_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1192_l1204_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9602,7 +11803,13 @@ fn c1192_l1204_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1205 fn c1193_l1205_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1193_l1205_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9610,7 +11817,13 @@ fn c1193_l1205_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1206 fn c1194_l1206_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1194_l1206_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9618,7 +11831,13 @@ fn c1194_l1206_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1207 fn c1195_l1207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1195_l1207_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9626,7 +11845,13 @@ fn c1195_l1207_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1208 fn c1196_l1208_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1196_l1208_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9634,7 +11859,13 @@ fn c1196_l1208_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1209 fn c1197_l1209_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1197_l1209_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9642,7 +11873,13 @@ fn c1197_l1209_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1210 fn c1198_l1210_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1198_l1210_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9650,7 +11887,13 @@ fn c1198_l1210_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1211 fn c1199_l1211_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1199_l1211_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9658,7 +11901,13 @@ fn c1199_l1211_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1212 fn c1200_l1212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1200_l1212_action_invoke"); - let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "lt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9826,7 +12075,10 @@ fn c1220_l1232_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1233 fn c1221_l1233_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1221_l1233_action_invoke"); - let result = instance.call("le", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "le", + &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9834,7 +12086,10 @@ fn c1221_l1233_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1234 fn c1222_l1234_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1222_l1234_action_invoke"); - let result = instance.call("le", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "le", + &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -9842,7 +12097,10 @@ fn c1222_l1234_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1235 fn c1223_l1235_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1223_l1235_action_invoke"); - let result = instance.call("le", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "le", + &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9850,7 +12108,10 @@ fn c1223_l1235_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1236 fn c1224_l1236_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1224_l1236_action_invoke"); - let result = instance.call("le", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "le", + &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -9890,7 +12151,10 @@ fn c1228_l1240_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1241 fn c1229_l1241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1229_l1241_action_invoke"); - let result = instance.call("le", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "le", + &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9922,7 +12186,13 @@ fn c1232_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1245 fn c1233_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1233_l1245_action_invoke"); - let result = instance.call("le", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "le", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9930,7 +12200,13 @@ fn c1233_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1246 fn c1234_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1234_l1246_action_invoke"); - let result = instance.call("le", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "le", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9938,7 +12214,13 @@ fn c1234_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1247 fn c1235_l1247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1235_l1247_action_invoke"); - let result = instance.call("le", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "le", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9946,7 +12228,13 @@ fn c1235_l1247_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1248 fn c1236_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1236_l1248_action_invoke"); - let result = instance.call("le", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "le", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9954,7 +12242,13 @@ fn c1236_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1249 fn c1237_l1249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1237_l1249_action_invoke"); - let result = instance.call("le", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "le", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9962,7 +12256,13 @@ fn c1237_l1249_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1250 fn c1238_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1238_l1250_action_invoke"); - let result = instance.call("le", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "le", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9970,7 +12270,13 @@ fn c1238_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1251 fn c1239_l1251_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1239_l1251_action_invoke"); - let result = instance.call("le", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "le", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -9978,7 +12284,13 @@ fn c1239_l1251_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1252 fn c1240_l1252_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1240_l1252_action_invoke"); - let result = instance.call("le", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "le", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10786,7 +13098,10 @@ fn c1340_l1352_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1353 fn c1341_l1353_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1341_l1353_action_invoke"); - let result = instance.call("le", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "le", + &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10794,7 +13109,10 @@ fn c1341_l1353_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1354 fn c1342_l1354_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1342_l1354_action_invoke"); - let result = instance.call("le", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "le", + &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10802,7 +13120,10 @@ fn c1342_l1354_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1355 fn c1343_l1355_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1343_l1355_action_invoke"); - let result = instance.call("le", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "le", + &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10810,7 +13131,10 @@ fn c1343_l1355_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1356 fn c1344_l1356_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1344_l1356_action_invoke"); - let result = instance.call("le", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "le", + &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10850,7 +13174,10 @@ fn c1348_l1360_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1361 fn c1349_l1361_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1349_l1361_action_invoke"); - let result = instance.call("le", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "le", + &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10882,7 +13209,13 @@ fn c1352_l1364_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1365 fn c1353_l1365_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1353_l1365_action_invoke"); - let result = instance.call("le", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "le", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10890,7 +13223,13 @@ fn c1353_l1365_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1366 fn c1354_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1354_l1366_action_invoke"); - let result = instance.call("le", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "le", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10898,7 +13237,13 @@ fn c1354_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1367 fn c1355_l1367_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1355_l1367_action_invoke"); - let result = instance.call("le", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "le", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10906,7 +13251,13 @@ fn c1355_l1367_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1368 fn c1356_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1356_l1368_action_invoke"); - let result = instance.call("le", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "le", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10914,7 +13265,13 @@ fn c1356_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1369 fn c1357_l1369_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1357_l1369_action_invoke"); - let result = instance.call("le", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "le", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10922,7 +13279,13 @@ fn c1357_l1369_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1370 fn c1358_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1358_l1370_action_invoke"); - let result = instance.call("le", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "le", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10930,7 +13293,13 @@ fn c1358_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1371 fn c1359_l1371_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1359_l1371_action_invoke"); - let result = instance.call("le", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "le", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10938,7 +13307,13 @@ fn c1359_l1371_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1372 fn c1360_l1372_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1360_l1372_action_invoke"); - let result = instance.call("le", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "le", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11106,7 +13481,10 @@ fn c1380_l1392_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1393 fn c1381_l1393_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1381_l1393_action_invoke"); - let result = instance.call("le", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "le", + &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11114,7 +13492,10 @@ fn c1381_l1393_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1394 fn c1382_l1394_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1382_l1394_action_invoke"); - let result = instance.call("le", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "le", + &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11122,7 +13503,10 @@ fn c1382_l1394_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1395 fn c1383_l1395_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1383_l1395_action_invoke"); - let result = instance.call("le", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "le", + &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11130,7 +13514,10 @@ fn c1383_l1395_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1396 fn c1384_l1396_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1384_l1396_action_invoke"); - let result = instance.call("le", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "le", + &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11170,7 +13557,10 @@ fn c1388_l1400_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1401 fn c1389_l1401_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1389_l1401_action_invoke"); - let result = instance.call("le", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "le", + &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11202,7 +13592,13 @@ fn c1392_l1404_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1405 fn c1393_l1405_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1393_l1405_action_invoke"); - let result = instance.call("le", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "le", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11210,7 +13606,13 @@ fn c1393_l1405_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1406 fn c1394_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1394_l1406_action_invoke"); - let result = instance.call("le", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "le", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11218,7 +13620,13 @@ fn c1394_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1407 fn c1395_l1407_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1395_l1407_action_invoke"); - let result = instance.call("le", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "le", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11226,7 +13634,13 @@ fn c1395_l1407_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1408 fn c1396_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1396_l1408_action_invoke"); - let result = instance.call("le", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "le", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11234,7 +13648,13 @@ fn c1396_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1409 fn c1397_l1409_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1397_l1409_action_invoke"); - let result = instance.call("le", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "le", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11242,7 +13662,13 @@ fn c1397_l1409_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1410 fn c1398_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1398_l1410_action_invoke"); - let result = instance.call("le", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "le", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11250,7 +13676,13 @@ fn c1398_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1411 fn c1399_l1411_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1399_l1411_action_invoke"); - let result = instance.call("le", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "le", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11258,7 +13690,13 @@ fn c1399_l1411_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1412 fn c1400_l1412_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1400_l1412_action_invoke"); - let result = instance.call("le", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "le", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11266,7 +13704,10 @@ fn c1400_l1412_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1413 fn c1401_l1413_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1401_l1413_action_invoke"); - let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "le", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11274,7 +13715,10 @@ fn c1401_l1413_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1414 fn c1402_l1414_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1402_l1414_action_invoke"); - let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "le", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11282,7 +13726,10 @@ fn c1402_l1414_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1415 fn c1403_l1415_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1403_l1415_action_invoke"); - let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "le", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11290,7 +13737,10 @@ fn c1403_l1415_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1416 fn c1404_l1416_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1404_l1416_action_invoke"); - let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "le", + &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11362,7 +13812,10 @@ fn c1412_l1424_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1425 fn c1413_l1425_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1413_l1425_action_invoke"); - let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "le", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11370,7 +13823,10 @@ fn c1413_l1425_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1426 fn c1414_l1426_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1414_l1426_action_invoke"); - let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "le", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11378,7 +13834,10 @@ fn c1414_l1426_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1427 fn c1415_l1427_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1415_l1427_action_invoke"); - let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "le", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11386,7 +13845,10 @@ fn c1415_l1427_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1428 fn c1416_l1428_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1416_l1428_action_invoke"); - let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "le", + &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11394,7 +13856,10 @@ fn c1416_l1428_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1429 fn c1417_l1429_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1417_l1429_action_invoke"); - let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "le", + &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11402,7 +13867,10 @@ fn c1417_l1429_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1430 fn c1418_l1430_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1418_l1430_action_invoke"); - let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "le", + &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11410,7 +13878,10 @@ fn c1418_l1430_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1431 fn c1419_l1431_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1419_l1431_action_invoke"); - let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "le", + &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11418,7 +13889,10 @@ fn c1419_l1431_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1432 fn c1420_l1432_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1420_l1432_action_invoke"); - let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "le", + &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11426,7 +13900,13 @@ fn c1420_l1432_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1433 fn c1421_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1421_l1433_action_invoke"); - let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11434,7 +13914,13 @@ fn c1421_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1434 fn c1422_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1422_l1434_action_invoke"); - let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11442,7 +13928,13 @@ fn c1422_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1435 fn c1423_l1435_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1423_l1435_action_invoke"); - let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11450,7 +13942,13 @@ fn c1423_l1435_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1436 fn c1424_l1436_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1424_l1436_action_invoke"); - let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11490,7 +13988,13 @@ fn c1428_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1441 fn c1429_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1429_l1441_action_invoke"); - let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11498,7 +14002,13 @@ fn c1429_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1442 fn c1430_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1430_l1442_action_invoke"); - let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11506,7 +14016,13 @@ fn c1430_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1443 fn c1431_l1443_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1431_l1443_action_invoke"); - let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11514,7 +14030,13 @@ fn c1431_l1443_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1444 fn c1432_l1444_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1432_l1444_action_invoke"); - let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -11522,7 +14044,13 @@ fn c1432_l1444_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1445 fn c1433_l1445_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1433_l1445_action_invoke"); - let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "le", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11530,7 +14058,13 @@ fn c1433_l1445_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1446 fn c1434_l1446_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1434_l1446_action_invoke"); - let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "le", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11538,7 +14072,13 @@ fn c1434_l1446_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1447 fn c1435_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1435_l1447_action_invoke"); - let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "le", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11546,7 +14086,13 @@ fn c1435_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1448 fn c1436_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1436_l1448_action_invoke"); - let result = instance.call("le", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "le", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11554,7 +14100,13 @@ fn c1436_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1449 fn c1437_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1437_l1449_action_invoke"); - let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "le", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11562,7 +14114,13 @@ fn c1437_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1450 fn c1438_l1450_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1438_l1450_action_invoke"); - let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "le", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11570,7 +14128,13 @@ fn c1438_l1450_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1451 fn c1439_l1451_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1439_l1451_action_invoke"); - let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "le", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11578,7 +14142,13 @@ fn c1439_l1451_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1452 fn c1440_l1452_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1440_l1452_action_invoke"); - let result = instance.call("le", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "le", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11906,7 +14476,10 @@ fn c1480_l1492_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1493 fn c1481_l1493_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1481_l1493_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]); + let result = instance.call( + "le", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12002,7 +14575,10 @@ fn c1492_l1504_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1505 fn c1493_l1505_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1493_l1505_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]); + let result = instance.call( + "le", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12034,7 +14610,10 @@ fn c1496_l1508_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1509 fn c1497_l1509_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1497_l1509_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]); + let result = instance.call( + "le", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12066,7 +14645,13 @@ fn c1500_l1512_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1513 fn c1501_l1513_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1501_l1513_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12074,7 +14659,13 @@ fn c1501_l1513_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1514 fn c1502_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1502_l1514_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12082,7 +14673,13 @@ fn c1502_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1515 fn c1503_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1503_l1515_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12090,7 +14687,13 @@ fn c1503_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1516 fn c1504_l1516_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1504_l1516_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12130,7 +14733,10 @@ fn c1508_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1521 fn c1509_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1509_l1521_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "le", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12138,7 +14744,10 @@ fn c1509_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1522 fn c1510_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1510_l1522_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "le", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12146,7 +14755,10 @@ fn c1510_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1523 fn c1511_l1523_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1511_l1523_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "le", + &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12154,7 +14766,10 @@ fn c1511_l1523_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1524 fn c1512_l1524_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1512_l1524_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "le", + &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -12162,7 +14777,13 @@ fn c1512_l1524_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1525 fn c1513_l1525_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1513_l1525_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12170,7 +14791,13 @@ fn c1513_l1525_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1526 fn c1514_l1526_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1514_l1526_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12178,7 +14805,13 @@ fn c1514_l1526_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1527 fn c1515_l1527_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1515_l1527_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12186,7 +14819,13 @@ fn c1515_l1527_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1528 fn c1516_l1528_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1516_l1528_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12194,7 +14833,13 @@ fn c1516_l1528_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1529 fn c1517_l1529_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1517_l1529_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12202,7 +14847,13 @@ fn c1517_l1529_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1530 fn c1518_l1530_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1518_l1530_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12210,7 +14861,13 @@ fn c1518_l1530_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1531 fn c1519_l1531_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1519_l1531_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12218,7 +14875,13 @@ fn c1519_l1531_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1532 fn c1520_l1532_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1520_l1532_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12226,7 +14889,13 @@ fn c1520_l1532_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1533 fn c1521_l1533_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1521_l1533_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12234,7 +14903,13 @@ fn c1521_l1533_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1534 fn c1522_l1534_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1522_l1534_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12242,7 +14917,13 @@ fn c1522_l1534_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1535 fn c1523_l1535_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1523_l1535_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12250,7 +14931,13 @@ fn c1523_l1535_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1536 fn c1524_l1536_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1524_l1536_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12258,7 +14945,13 @@ fn c1524_l1536_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1537 fn c1525_l1537_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1525_l1537_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12266,7 +14959,13 @@ fn c1525_l1537_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1538 fn c1526_l1538_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1526_l1538_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12274,7 +14973,13 @@ fn c1526_l1538_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1539 fn c1527_l1539_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1527_l1539_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12282,7 +14987,13 @@ fn c1527_l1539_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1540 fn c1528_l1540_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1528_l1540_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12418,7 +15129,13 @@ fn c1544_l1556_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1557 fn c1545_l1557_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1545_l1557_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12426,7 +15143,13 @@ fn c1545_l1557_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1558 fn c1546_l1558_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1546_l1558_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12434,7 +15157,13 @@ fn c1546_l1558_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1559 fn c1547_l1559_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1547_l1559_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12442,7 +15171,13 @@ fn c1547_l1559_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1560 fn c1548_l1560_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1548_l1560_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12450,7 +15185,13 @@ fn c1548_l1560_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1561 fn c1549_l1561_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1549_l1561_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12458,7 +15199,13 @@ fn c1549_l1561_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1562 fn c1550_l1562_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1550_l1562_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12466,7 +15213,13 @@ fn c1550_l1562_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1563 fn c1551_l1563_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1551_l1563_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12474,7 +15227,13 @@ fn c1551_l1563_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1564 fn c1552_l1564_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1552_l1564_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12482,7 +15241,13 @@ fn c1552_l1564_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1565 fn c1553_l1565_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1553_l1565_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12490,7 +15255,13 @@ fn c1553_l1565_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1566 fn c1554_l1566_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1554_l1566_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12498,7 +15269,13 @@ fn c1554_l1566_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1567 fn c1555_l1567_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1555_l1567_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12506,7 +15283,13 @@ fn c1555_l1567_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1568 fn c1556_l1568_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1556_l1568_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12514,7 +15297,13 @@ fn c1556_l1568_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1569 fn c1557_l1569_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1557_l1569_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12522,7 +15311,13 @@ fn c1557_l1569_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1570 fn c1558_l1570_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1558_l1570_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12530,7 +15325,13 @@ fn c1558_l1570_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1571 fn c1559_l1571_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1559_l1571_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12538,7 +15339,13 @@ fn c1559_l1571_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1572 fn c1560_l1572_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1560_l1572_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12546,7 +15353,13 @@ fn c1560_l1572_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1573 fn c1561_l1573_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1561_l1573_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12554,7 +15367,13 @@ fn c1561_l1573_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1574 fn c1562_l1574_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1562_l1574_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12562,7 +15381,13 @@ fn c1562_l1574_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1575 fn c1563_l1575_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1563_l1575_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12570,7 +15395,13 @@ fn c1563_l1575_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1576 fn c1564_l1576_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1564_l1576_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12578,7 +15409,13 @@ fn c1564_l1576_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1577 fn c1565_l1577_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1565_l1577_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12586,7 +15423,13 @@ fn c1565_l1577_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1578 fn c1566_l1578_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1566_l1578_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12594,7 +15437,13 @@ fn c1566_l1578_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1579 fn c1567_l1579_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1567_l1579_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12602,7 +15451,13 @@ fn c1567_l1579_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1580 fn c1568_l1580_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1568_l1580_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12674,7 +15529,13 @@ fn c1576_l1588_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1589 fn c1577_l1589_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1577_l1589_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12682,7 +15543,13 @@ fn c1577_l1589_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1590 fn c1578_l1590_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1578_l1590_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12690,7 +15557,13 @@ fn c1578_l1590_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1591 fn c1579_l1591_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1579_l1591_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12698,7 +15571,13 @@ fn c1579_l1591_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1592 fn c1580_l1592_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1580_l1592_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12706,7 +15585,13 @@ fn c1580_l1592_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1593 fn c1581_l1593_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1581_l1593_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12714,7 +15599,13 @@ fn c1581_l1593_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1594 fn c1582_l1594_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1582_l1594_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12722,7 +15613,13 @@ fn c1582_l1594_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1595 fn c1583_l1595_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1583_l1595_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12730,7 +15627,13 @@ fn c1583_l1595_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1596 fn c1584_l1596_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1584_l1596_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12738,7 +15641,13 @@ fn c1584_l1596_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1597 fn c1585_l1597_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1585_l1597_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12746,7 +15655,13 @@ fn c1585_l1597_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1598 fn c1586_l1598_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1586_l1598_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12754,7 +15669,13 @@ fn c1586_l1598_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1599 fn c1587_l1599_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1587_l1599_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12762,7 +15683,13 @@ fn c1587_l1599_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1600 fn c1588_l1600_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1588_l1600_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12770,7 +15697,13 @@ fn c1588_l1600_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1601 fn c1589_l1601_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1589_l1601_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12778,7 +15711,13 @@ fn c1589_l1601_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1602 fn c1590_l1602_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1590_l1602_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12786,7 +15725,13 @@ fn c1590_l1602_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1603 fn c1591_l1603_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1591_l1603_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12794,7 +15739,13 @@ fn c1591_l1603_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1604 fn c1592_l1604_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1592_l1604_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12802,7 +15753,13 @@ fn c1592_l1604_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1605 fn c1593_l1605_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1593_l1605_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12810,7 +15767,13 @@ fn c1593_l1605_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1606 fn c1594_l1606_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1594_l1606_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12818,7 +15781,13 @@ fn c1594_l1606_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1607 fn c1595_l1607_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1595_l1607_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12826,7 +15795,13 @@ fn c1595_l1607_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1608 fn c1596_l1608_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1596_l1608_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12834,7 +15809,13 @@ fn c1596_l1608_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1609 fn c1597_l1609_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1597_l1609_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12842,7 +15823,13 @@ fn c1597_l1609_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1610 fn c1598_l1610_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1598_l1610_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12850,7 +15837,13 @@ fn c1598_l1610_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1611 fn c1599_l1611_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1599_l1611_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -12858,7 +15851,13 @@ fn c1599_l1611_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1612 fn c1600_l1612_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1600_l1612_action_invoke"); - let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "le", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13026,7 +16025,10 @@ fn c1620_l1632_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1633 fn c1621_l1633_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1621_l1633_action_invoke"); - let result = instance.call("gt", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "gt", + &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13034,7 +16036,10 @@ fn c1621_l1633_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1634 fn c1622_l1634_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1622_l1634_action_invoke"); - let result = instance.call("gt", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "gt", + &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13042,7 +16047,10 @@ fn c1622_l1634_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1635 fn c1623_l1635_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1623_l1635_action_invoke"); - let result = instance.call("gt", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "gt", + &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13050,7 +16058,10 @@ fn c1623_l1635_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1636 fn c1624_l1636_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1624_l1636_action_invoke"); - let result = instance.call("gt", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "gt", + &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13090,7 +16101,10 @@ fn c1628_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1641 fn c1629_l1641_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1629_l1641_action_invoke"); - let result = instance.call("gt", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13122,7 +16136,13 @@ fn c1632_l1644_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1645 fn c1633_l1645_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1633_l1645_action_invoke"); - let result = instance.call("gt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "gt", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13130,7 +16150,13 @@ fn c1633_l1645_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1646 fn c1634_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1634_l1646_action_invoke"); - let result = instance.call("gt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "gt", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13138,7 +16164,13 @@ fn c1634_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1647 fn c1635_l1647_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1635_l1647_action_invoke"); - let result = instance.call("gt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "gt", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13146,7 +16178,13 @@ fn c1635_l1647_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1648 fn c1636_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1636_l1648_action_invoke"); - let result = instance.call("gt", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "gt", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13154,7 +16192,13 @@ fn c1636_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1649 fn c1637_l1649_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1637_l1649_action_invoke"); - let result = instance.call("gt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "gt", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13162,7 +16206,13 @@ fn c1637_l1649_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1650 fn c1638_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1638_l1650_action_invoke"); - let result = instance.call("gt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "gt", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13170,7 +16220,13 @@ fn c1638_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1651 fn c1639_l1651_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1639_l1651_action_invoke"); - let result = instance.call("gt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "gt", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13178,7 +16234,13 @@ fn c1639_l1651_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1652 fn c1640_l1652_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1640_l1652_action_invoke"); - let result = instance.call("gt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "gt", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -13986,7 +17048,10 @@ fn c1740_l1752_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1753 fn c1741_l1753_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1741_l1753_action_invoke"); - let result = instance.call("gt", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "gt", + &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -13994,7 +17059,10 @@ fn c1741_l1753_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1754 fn c1742_l1754_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1742_l1754_action_invoke"); - let result = instance.call("gt", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "gt", + &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14002,7 +17070,10 @@ fn c1742_l1754_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1755 fn c1743_l1755_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1743_l1755_action_invoke"); - let result = instance.call("gt", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "gt", + &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14010,7 +17081,10 @@ fn c1743_l1755_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1756 fn c1744_l1756_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1744_l1756_action_invoke"); - let result = instance.call("gt", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "gt", + &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14050,7 +17124,10 @@ fn c1748_l1760_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1761 fn c1749_l1761_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1749_l1761_action_invoke"); - let result = instance.call("gt", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14082,7 +17159,13 @@ fn c1752_l1764_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1765 fn c1753_l1765_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1753_l1765_action_invoke"); - let result = instance.call("gt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "gt", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14090,7 +17173,13 @@ fn c1753_l1765_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1766 fn c1754_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1754_l1766_action_invoke"); - let result = instance.call("gt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "gt", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14098,7 +17187,13 @@ fn c1754_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1767 fn c1755_l1767_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1755_l1767_action_invoke"); - let result = instance.call("gt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "gt", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14106,7 +17201,13 @@ fn c1755_l1767_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1768 fn c1756_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1756_l1768_action_invoke"); - let result = instance.call("gt", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "gt", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14114,7 +17215,13 @@ fn c1756_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1769 fn c1757_l1769_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1757_l1769_action_invoke"); - let result = instance.call("gt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "gt", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14122,7 +17229,13 @@ fn c1757_l1769_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1770 fn c1758_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1758_l1770_action_invoke"); - let result = instance.call("gt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "gt", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14130,7 +17243,13 @@ fn c1758_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1771 fn c1759_l1771_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1759_l1771_action_invoke"); - let result = instance.call("gt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "gt", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14138,7 +17257,13 @@ fn c1759_l1771_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1772 fn c1760_l1772_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1760_l1772_action_invoke"); - let result = instance.call("gt", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "gt", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14306,7 +17431,10 @@ fn c1780_l1792_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1793 fn c1781_l1793_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1781_l1793_action_invoke"); - let result = instance.call("gt", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "gt", + &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14314,7 +17442,10 @@ fn c1781_l1793_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1794 fn c1782_l1794_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1782_l1794_action_invoke"); - let result = instance.call("gt", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "gt", + &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14322,7 +17453,10 @@ fn c1782_l1794_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1795 fn c1783_l1795_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1783_l1795_action_invoke"); - let result = instance.call("gt", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "gt", + &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14330,7 +17464,10 @@ fn c1783_l1795_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1796 fn c1784_l1796_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1784_l1796_action_invoke"); - let result = instance.call("gt", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "gt", + &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14370,7 +17507,10 @@ fn c1788_l1800_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1801 fn c1789_l1801_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1789_l1801_action_invoke"); - let result = instance.call("gt", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14402,7 +17542,13 @@ fn c1792_l1804_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1805 fn c1793_l1805_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1793_l1805_action_invoke"); - let result = instance.call("gt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "gt", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14410,7 +17556,13 @@ fn c1793_l1805_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1806 fn c1794_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1794_l1806_action_invoke"); - let result = instance.call("gt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "gt", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14418,7 +17570,13 @@ fn c1794_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1807 fn c1795_l1807_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1795_l1807_action_invoke"); - let result = instance.call("gt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "gt", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14426,7 +17584,13 @@ fn c1795_l1807_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1808 fn c1796_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1796_l1808_action_invoke"); - let result = instance.call("gt", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "gt", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14434,7 +17598,13 @@ fn c1796_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1809 fn c1797_l1809_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1797_l1809_action_invoke"); - let result = instance.call("gt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "gt", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14442,7 +17612,13 @@ fn c1797_l1809_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1810 fn c1798_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1798_l1810_action_invoke"); - let result = instance.call("gt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "gt", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14450,7 +17626,13 @@ fn c1798_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1811 fn c1799_l1811_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1799_l1811_action_invoke"); - let result = instance.call("gt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "gt", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14458,7 +17640,13 @@ fn c1799_l1811_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1812 fn c1800_l1812_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1800_l1812_action_invoke"); - let result = instance.call("gt", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "gt", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14466,7 +17654,10 @@ fn c1800_l1812_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1813 fn c1801_l1813_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1801_l1813_action_invoke"); - let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "gt", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14474,7 +17665,10 @@ fn c1801_l1813_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1814 fn c1802_l1814_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1802_l1814_action_invoke"); - let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "gt", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14482,7 +17676,10 @@ fn c1802_l1814_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1815 fn c1803_l1815_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1803_l1815_action_invoke"); - let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "gt", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14490,7 +17687,10 @@ fn c1803_l1815_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1816 fn c1804_l1816_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1804_l1816_action_invoke"); - let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "gt", + &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14562,7 +17762,10 @@ fn c1812_l1824_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1825 fn c1813_l1825_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1813_l1825_action_invoke"); - let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "gt", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14570,7 +17773,10 @@ fn c1813_l1825_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1826 fn c1814_l1826_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1814_l1826_action_invoke"); - let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "gt", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14578,7 +17784,10 @@ fn c1814_l1826_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1827 fn c1815_l1827_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1815_l1827_action_invoke"); - let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "gt", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14586,7 +17795,10 @@ fn c1815_l1827_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1828 fn c1816_l1828_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1816_l1828_action_invoke"); - let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "gt", + &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14594,7 +17806,10 @@ fn c1816_l1828_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1829 fn c1817_l1829_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1817_l1829_action_invoke"); - let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "gt", + &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14602,7 +17817,10 @@ fn c1817_l1829_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1830 fn c1818_l1830_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1818_l1830_action_invoke"); - let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "gt", + &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14610,7 +17828,10 @@ fn c1818_l1830_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1831 fn c1819_l1831_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1819_l1831_action_invoke"); - let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "gt", + &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14618,7 +17839,10 @@ fn c1819_l1831_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1832 fn c1820_l1832_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1820_l1832_action_invoke"); - let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "gt", + &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14626,7 +17850,13 @@ fn c1820_l1832_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1833 fn c1821_l1833_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1821_l1833_action_invoke"); - let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14634,7 +17864,13 @@ fn c1821_l1833_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1834 fn c1822_l1834_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1822_l1834_action_invoke"); - let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14642,7 +17878,13 @@ fn c1822_l1834_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1835 fn c1823_l1835_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1823_l1835_action_invoke"); - let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14650,7 +17892,13 @@ fn c1823_l1835_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1836 fn c1824_l1836_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1824_l1836_action_invoke"); - let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14690,7 +17938,13 @@ fn c1828_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1841 fn c1829_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1829_l1841_action_invoke"); - let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14698,7 +17952,13 @@ fn c1829_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1842 fn c1830_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1830_l1842_action_invoke"); - let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14706,7 +17966,13 @@ fn c1830_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1843 fn c1831_l1843_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1831_l1843_action_invoke"); - let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -14714,7 +17980,13 @@ fn c1831_l1843_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1844 fn c1832_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1832_l1844_action_invoke"); - let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14722,7 +17994,13 @@ fn c1832_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1845 fn c1833_l1845_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1833_l1845_action_invoke"); - let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "gt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14730,7 +18008,13 @@ fn c1833_l1845_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1846 fn c1834_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1834_l1846_action_invoke"); - let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "gt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14738,7 +18022,13 @@ fn c1834_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1847 fn c1835_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1835_l1847_action_invoke"); - let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "gt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14746,7 +18036,13 @@ fn c1835_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1848 fn c1836_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1836_l1848_action_invoke"); - let result = instance.call("gt", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "gt", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14754,7 +18050,13 @@ fn c1836_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1849 fn c1837_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1837_l1849_action_invoke"); - let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "gt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14762,7 +18064,13 @@ fn c1837_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1850 fn c1838_l1850_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1838_l1850_action_invoke"); - let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "gt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14770,7 +18078,13 @@ fn c1838_l1850_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1851 fn c1839_l1851_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1839_l1851_action_invoke"); - let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "gt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -14778,7 +18092,13 @@ fn c1839_l1851_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1852 fn c1840_l1852_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1840_l1852_action_invoke"); - let result = instance.call("gt", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "gt", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15106,7 +18426,10 @@ fn c1880_l1892_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1893 fn c1881_l1893_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1881_l1893_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]); + let result = instance.call( + "gt", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15202,7 +18525,10 @@ fn c1892_l1904_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1905 fn c1893_l1905_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1893_l1905_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]); + let result = instance.call( + "gt", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15234,7 +18560,10 @@ fn c1896_l1908_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1909 fn c1897_l1909_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1897_l1909_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]); + let result = instance.call( + "gt", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15266,7 +18595,13 @@ fn c1900_l1912_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1913 fn c1901_l1913_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1901_l1913_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15274,7 +18609,13 @@ fn c1901_l1913_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1914 fn c1902_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1902_l1914_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15282,7 +18623,13 @@ fn c1902_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1915 fn c1903_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1903_l1915_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15290,7 +18637,13 @@ fn c1903_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1916 fn c1904_l1916_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1904_l1916_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15330,7 +18683,10 @@ fn c1908_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1921 fn c1909_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1909_l1921_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15338,7 +18694,10 @@ fn c1909_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1922 fn c1910_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1910_l1922_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "gt", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15346,7 +18705,10 @@ fn c1910_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1923 fn c1911_l1923_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1911_l1923_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -15354,7 +18716,10 @@ fn c1911_l1923_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1924 fn c1912_l1924_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1912_l1924_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "gt", + &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15362,7 +18727,13 @@ fn c1912_l1924_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1925 fn c1913_l1925_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1913_l1925_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15370,7 +18741,13 @@ fn c1913_l1925_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1926 fn c1914_l1926_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1914_l1926_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15378,7 +18755,13 @@ fn c1914_l1926_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1927 fn c1915_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1915_l1927_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15386,7 +18769,13 @@ fn c1915_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1928 fn c1916_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1916_l1928_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15394,7 +18783,13 @@ fn c1916_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1929 fn c1917_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1917_l1929_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15402,7 +18797,13 @@ fn c1917_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1930 fn c1918_l1930_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1918_l1930_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15410,7 +18811,13 @@ fn c1918_l1930_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1931 fn c1919_l1931_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1919_l1931_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15418,7 +18825,13 @@ fn c1919_l1931_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1932 fn c1920_l1932_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1920_l1932_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15426,7 +18839,13 @@ fn c1920_l1932_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1933 fn c1921_l1933_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1921_l1933_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15434,7 +18853,13 @@ fn c1921_l1933_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1934 fn c1922_l1934_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1922_l1934_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15442,7 +18867,13 @@ fn c1922_l1934_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1935 fn c1923_l1935_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1923_l1935_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15450,7 +18881,13 @@ fn c1923_l1935_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1936 fn c1924_l1936_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1924_l1936_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15458,7 +18895,13 @@ fn c1924_l1936_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1937 fn c1925_l1937_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1925_l1937_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15466,7 +18909,13 @@ fn c1925_l1937_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1938 fn c1926_l1938_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1926_l1938_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15474,7 +18923,13 @@ fn c1926_l1938_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1939 fn c1927_l1939_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1927_l1939_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15482,7 +18937,13 @@ fn c1927_l1939_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1940 fn c1928_l1940_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1928_l1940_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15618,7 +19079,13 @@ fn c1944_l1956_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1957 fn c1945_l1957_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1945_l1957_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15626,7 +19093,13 @@ fn c1945_l1957_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1958 fn c1946_l1958_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1946_l1958_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15634,7 +19107,13 @@ fn c1946_l1958_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1959 fn c1947_l1959_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1947_l1959_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15642,7 +19121,13 @@ fn c1947_l1959_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1960 fn c1948_l1960_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1948_l1960_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15650,7 +19135,13 @@ fn c1948_l1960_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1961 fn c1949_l1961_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1949_l1961_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15658,7 +19149,13 @@ fn c1949_l1961_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1962 fn c1950_l1962_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1950_l1962_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15666,7 +19163,13 @@ fn c1950_l1962_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1963 fn c1951_l1963_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1951_l1963_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15674,7 +19177,13 @@ fn c1951_l1963_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1964 fn c1952_l1964_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1952_l1964_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15682,7 +19191,13 @@ fn c1952_l1964_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1965 fn c1953_l1965_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1953_l1965_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15690,7 +19205,13 @@ fn c1953_l1965_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1966 fn c1954_l1966_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1954_l1966_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15698,7 +19219,13 @@ fn c1954_l1966_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1967 fn c1955_l1967_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1955_l1967_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15706,7 +19233,13 @@ fn c1955_l1967_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1968 fn c1956_l1968_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1956_l1968_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15714,7 +19247,13 @@ fn c1956_l1968_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1969 fn c1957_l1969_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1957_l1969_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15722,7 +19261,13 @@ fn c1957_l1969_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1970 fn c1958_l1970_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1958_l1970_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15730,7 +19275,13 @@ fn c1958_l1970_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1971 fn c1959_l1971_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1959_l1971_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15738,7 +19289,13 @@ fn c1959_l1971_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1972 fn c1960_l1972_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1960_l1972_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15746,7 +19303,13 @@ fn c1960_l1972_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1973 fn c1961_l1973_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1961_l1973_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15754,7 +19317,13 @@ fn c1961_l1973_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1974 fn c1962_l1974_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1962_l1974_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15762,7 +19331,13 @@ fn c1962_l1974_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1975 fn c1963_l1975_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1963_l1975_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15770,7 +19345,13 @@ fn c1963_l1975_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1976 fn c1964_l1976_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1964_l1976_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15778,7 +19359,13 @@ fn c1964_l1976_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1977 fn c1965_l1977_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1965_l1977_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15786,7 +19373,13 @@ fn c1965_l1977_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1978 fn c1966_l1978_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1966_l1978_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15794,7 +19387,13 @@ fn c1966_l1978_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1979 fn c1967_l1979_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1967_l1979_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15802,7 +19401,13 @@ fn c1967_l1979_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1980 fn c1968_l1980_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1968_l1980_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15874,7 +19479,13 @@ fn c1976_l1988_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1989 fn c1977_l1989_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1977_l1989_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15882,7 +19493,13 @@ fn c1977_l1989_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1990 fn c1978_l1990_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1978_l1990_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15890,7 +19507,13 @@ fn c1978_l1990_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1991 fn c1979_l1991_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1979_l1991_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15898,7 +19521,13 @@ fn c1979_l1991_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1992 fn c1980_l1992_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1980_l1992_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15906,7 +19535,13 @@ fn c1980_l1992_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1993 fn c1981_l1993_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1981_l1993_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15914,7 +19549,13 @@ fn c1981_l1993_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1994 fn c1982_l1994_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1982_l1994_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15922,7 +19563,13 @@ fn c1982_l1994_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1995 fn c1983_l1995_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1983_l1995_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15930,7 +19577,13 @@ fn c1983_l1995_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1996 fn c1984_l1996_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1984_l1996_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15938,7 +19591,13 @@ fn c1984_l1996_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1997 fn c1985_l1997_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1985_l1997_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15946,7 +19605,13 @@ fn c1985_l1997_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1998 fn c1986_l1998_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1986_l1998_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15954,7 +19619,13 @@ fn c1986_l1998_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1999 fn c1987_l1999_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1987_l1999_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15962,7 +19633,13 @@ fn c1987_l1999_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2000 fn c1988_l2000_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1988_l2000_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15970,7 +19647,13 @@ fn c1988_l2000_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2001 fn c1989_l2001_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1989_l2001_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15978,7 +19661,13 @@ fn c1989_l2001_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2002 fn c1990_l2002_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1990_l2002_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15986,7 +19675,13 @@ fn c1990_l2002_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2003 fn c1991_l2003_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1991_l2003_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -15994,7 +19689,13 @@ fn c1991_l2003_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2004 fn c1992_l2004_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1992_l2004_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16002,7 +19703,13 @@ fn c1992_l2004_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2005 fn c1993_l2005_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1993_l2005_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16010,7 +19717,13 @@ fn c1993_l2005_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2006 fn c1994_l2006_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1994_l2006_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16018,7 +19731,13 @@ fn c1994_l2006_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2007 fn c1995_l2007_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1995_l2007_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16026,7 +19745,13 @@ fn c1995_l2007_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2008 fn c1996_l2008_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1996_l2008_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16034,7 +19759,13 @@ fn c1996_l2008_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2009 fn c1997_l2009_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1997_l2009_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16042,7 +19773,13 @@ fn c1997_l2009_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2010 fn c1998_l2010_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1998_l2010_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16050,7 +19787,13 @@ fn c1998_l2010_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2011 fn c1999_l2011_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1999_l2011_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16058,7 +19801,13 @@ fn c1999_l2011_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2012 fn c2000_l2012_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2000_l2012_action_invoke"); - let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "gt", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16226,7 +19975,10 @@ fn c2020_l2032_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2033 fn c2021_l2033_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2021_l2033_action_invoke"); - let result = instance.call("ge", &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ge", + &[Value::F64((-0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16234,7 +19986,10 @@ fn c2021_l2033_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2034 fn c2022_l2034_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2022_l2034_action_invoke"); - let result = instance.call("ge", &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ge", + &[Value::F64((-0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16242,7 +19997,10 @@ fn c2022_l2034_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2035 fn c2023_l2035_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2023_l2035_action_invoke"); - let result = instance.call("ge", &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ge", + &[Value::F64((0.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16250,7 +20008,10 @@ fn c2023_l2035_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2036 fn c2024_l2036_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2024_l2036_action_invoke"); - let result = instance.call("ge", &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ge", + &[Value::F64((0.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16290,7 +20051,10 @@ fn c2028_l2040_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2041 fn c2029_l2041_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2029_l2041_action_invoke"); - let result = instance.call("ge", &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[Value::F64((-0.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -16322,7 +20086,13 @@ fn c2032_l2044_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2045 fn c2033_l2045_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2033_l2045_action_invoke"); - let result = instance.call("ge", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ge", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16330,7 +20100,13 @@ fn c2033_l2045_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2046 fn c2034_l2046_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2034_l2046_action_invoke"); - let result = instance.call("ge", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ge", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16338,7 +20114,13 @@ fn c2034_l2046_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2047 fn c2035_l2047_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2035_l2047_action_invoke"); - let result = instance.call("ge", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ge", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16346,7 +20128,13 @@ fn c2035_l2047_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2048 fn c2036_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2036_l2048_action_invoke"); - let result = instance.call("ge", &[Value::F64((-0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ge", + &[ + Value::F64((-0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16354,7 +20142,13 @@ fn c2036_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2049 fn c2037_l2049_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2037_l2049_action_invoke"); - let result = instance.call("ge", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ge", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16362,7 +20156,13 @@ fn c2037_l2049_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2050 fn c2038_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2038_l2050_action_invoke"); - let result = instance.call("ge", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ge", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16370,7 +20170,13 @@ fn c2038_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2051 fn c2039_l2051_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2039_l2051_action_invoke"); - let result = instance.call("ge", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ge", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -16378,7 +20184,13 @@ fn c2039_l2051_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2052 fn c2040_l2052_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2040_l2052_action_invoke"); - let result = instance.call("ge", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ge", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17186,7 +20998,10 @@ fn c2140_l2152_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2153 fn c2141_l2153_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2141_l2153_action_invoke"); - let result = instance.call("ge", &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ge", + &[Value::F64((-0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17194,7 +21009,10 @@ fn c2141_l2153_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2154 fn c2142_l2154_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2142_l2154_action_invoke"); - let result = instance.call("ge", &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ge", + &[Value::F64((-0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17202,7 +21020,10 @@ fn c2142_l2154_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2155 fn c2143_l2155_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2143_l2155_action_invoke"); - let result = instance.call("ge", &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ge", + &[Value::F64((0.5f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17210,7 +21031,10 @@ fn c2143_l2155_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2156 fn c2144_l2156_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2144_l2156_action_invoke"); - let result = instance.call("ge", &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ge", + &[Value::F64((0.5f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17250,7 +21074,10 @@ fn c2148_l2160_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2161 fn c2149_l2161_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2149_l2161_action_invoke"); - let result = instance.call("ge", &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[Value::F64((-0.5f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17282,7 +21109,13 @@ fn c2152_l2164_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2165 fn c2153_l2165_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2153_l2165_action_invoke"); - let result = instance.call("ge", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ge", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17290,7 +21123,13 @@ fn c2153_l2165_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2166 fn c2154_l2166_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2154_l2166_action_invoke"); - let result = instance.call("ge", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ge", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17298,7 +21137,13 @@ fn c2154_l2166_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2167 fn c2155_l2167_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2155_l2167_action_invoke"); - let result = instance.call("ge", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ge", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17306,7 +21151,13 @@ fn c2155_l2167_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2168 fn c2156_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2156_l2168_action_invoke"); - let result = instance.call("ge", &[Value::F64((-0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ge", + &[ + Value::F64((-0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17314,7 +21165,13 @@ fn c2156_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2169 fn c2157_l2169_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2157_l2169_action_invoke"); - let result = instance.call("ge", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ge", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17322,7 +21179,13 @@ fn c2157_l2169_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2170 fn c2158_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2158_l2170_action_invoke"); - let result = instance.call("ge", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ge", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17330,7 +21193,13 @@ fn c2158_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2171 fn c2159_l2171_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2159_l2171_action_invoke"); - let result = instance.call("ge", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ge", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17338,7 +21207,13 @@ fn c2159_l2171_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2172 fn c2160_l2172_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2160_l2172_action_invoke"); - let result = instance.call("ge", &[Value::F64((0.5f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ge", + &[ + Value::F64((0.5f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17506,7 +21381,10 @@ fn c2180_l2192_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2193 fn c2181_l2193_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2181_l2193_action_invoke"); - let result = instance.call("ge", &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ge", + &[Value::F64((-1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17514,7 +21392,10 @@ fn c2181_l2193_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2194 fn c2182_l2194_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2182_l2194_action_invoke"); - let result = instance.call("ge", &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ge", + &[Value::F64((-1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17522,7 +21403,10 @@ fn c2182_l2194_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2195 fn c2183_l2195_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2183_l2195_action_invoke"); - let result = instance.call("ge", &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ge", + &[Value::F64((1.0f64)), Value::F64((-6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17530,7 +21414,10 @@ fn c2183_l2195_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2196 fn c2184_l2196_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2184_l2196_action_invoke"); - let result = instance.call("ge", &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ge", + &[Value::F64((1.0f64)), Value::F64((6.283185307179586f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17570,7 +21457,10 @@ fn c2188_l2200_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2201 fn c2189_l2201_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2189_l2201_action_invoke"); - let result = instance.call("ge", &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[Value::F64((-1.0f64)), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17602,7 +21492,13 @@ fn c2192_l2204_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2205 fn c2193_l2205_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2193_l2205_action_invoke"); - let result = instance.call("ge", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ge", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17610,7 +21506,13 @@ fn c2193_l2205_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2206 fn c2194_l2206_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2194_l2206_action_invoke"); - let result = instance.call("ge", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ge", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17618,7 +21520,13 @@ fn c2194_l2206_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2207 fn c2195_l2207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2195_l2207_action_invoke"); - let result = instance.call("ge", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ge", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17626,7 +21534,13 @@ fn c2195_l2207_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2208 fn c2196_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2196_l2208_action_invoke"); - let result = instance.call("ge", &[Value::F64((-1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ge", + &[ + Value::F64((-1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17634,7 +21548,13 @@ fn c2196_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2209 fn c2197_l2209_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2197_l2209_action_invoke"); - let result = instance.call("ge", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ge", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17642,7 +21562,13 @@ fn c2197_l2209_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2210 fn c2198_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2198_l2210_action_invoke"); - let result = instance.call("ge", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ge", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17650,7 +21576,13 @@ fn c2198_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2211 fn c2199_l2211_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2199_l2211_action_invoke"); - let result = instance.call("ge", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ge", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17658,7 +21590,13 @@ fn c2199_l2211_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2212 fn c2200_l2212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2200_l2212_action_invoke"); - let result = instance.call("ge", &[Value::F64((1.0f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ge", + &[ + Value::F64((1.0f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17666,7 +21604,10 @@ fn c2200_l2212_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2213 fn c2201_l2213_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2201_l2213_action_invoke"); - let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "ge", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17674,7 +21615,10 @@ fn c2201_l2213_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2214 fn c2202_l2214_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2202_l2214_action_invoke"); - let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "ge", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17682,7 +21626,10 @@ fn c2202_l2214_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2215 fn c2203_l2215_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2203_l2215_action_invoke"); - let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "ge", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17690,7 +21637,10 @@ fn c2203_l2215_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2216 fn c2204_l2216_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2204_l2216_action_invoke"); - let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))]); + let result = instance.call( + "ge", + &[Value::F64((6.283185307179586f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17762,7 +21712,10 @@ fn c2212_l2224_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2225 fn c2213_l2225_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2213_l2225_action_invoke"); - let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "ge", + &[Value::F64((-6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17770,7 +21723,10 @@ fn c2213_l2225_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2226 fn c2214_l2226_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2214_l2226_action_invoke"); - let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "ge", + &[Value::F64((-6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17778,7 +21734,10 @@ fn c2214_l2226_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2227 fn c2215_l2227_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2215_l2227_action_invoke"); - let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))]); + let result = instance.call( + "ge", + &[Value::F64((6.283185307179586f64)), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17786,7 +21745,10 @@ fn c2215_l2227_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2228 fn c2216_l2228_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2216_l2228_action_invoke"); - let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))]); + let result = instance.call( + "ge", + &[Value::F64((6.283185307179586f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17794,7 +21756,10 @@ fn c2216_l2228_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2229 fn c2217_l2229_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2217_l2229_action_invoke"); - let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "ge", + &[Value::F64((-6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17802,7 +21767,10 @@ fn c2217_l2229_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2230 fn c2218_l2230_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2218_l2230_action_invoke"); - let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "ge", + &[Value::F64((-6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17810,7 +21778,10 @@ fn c2218_l2230_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2231 fn c2219_l2231_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2219_l2231_action_invoke"); - let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "ge", + &[Value::F64((6.283185307179586f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17818,7 +21789,10 @@ fn c2219_l2231_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2232 fn c2220_l2232_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2220_l2232_action_invoke"); - let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))]); + let result = instance.call( + "ge", + &[Value::F64((6.283185307179586f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17826,7 +21800,13 @@ fn c2220_l2232_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2233 fn c2221_l2233_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2221_l2233_action_invoke"); - let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17834,7 +21814,13 @@ fn c2221_l2233_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2234 fn c2222_l2234_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2222_l2234_action_invoke"); - let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17842,7 +21828,13 @@ fn c2222_l2234_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2235 fn c2223_l2235_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2223_l2235_action_invoke"); - let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17850,7 +21842,13 @@ fn c2223_l2235_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2236 fn c2224_l2236_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2224_l2236_action_invoke"); - let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64((6.283185307179586f64)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17890,7 +21888,13 @@ fn c2228_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2241 fn c2229_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2229_l2241_action_invoke"); - let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17898,7 +21902,13 @@ fn c2229_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2242 fn c2230_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2230_l2242_action_invoke"); - let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17906,7 +21916,13 @@ fn c2230_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2243 fn c2231_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2231_l2243_action_invoke"); - let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -17914,7 +21930,13 @@ fn c2231_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2244 fn c2232_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2232_l2244_action_invoke"); - let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17922,7 +21944,13 @@ fn c2232_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2245 fn c2233_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2233_l2245_action_invoke"); - let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ge", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17930,7 +21958,13 @@ fn c2233_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2246 fn c2234_l2246_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2234_l2246_action_invoke"); - let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ge", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17938,7 +21972,13 @@ fn c2234_l2246_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2247 fn c2235_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2235_l2247_action_invoke"); - let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ge", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17946,7 +21986,13 @@ fn c2235_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2248 fn c2236_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2236_l2248_action_invoke"); - let result = instance.call("ge", &[Value::F64((-6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ge", + &[ + Value::F64((-6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17954,7 +22000,13 @@ fn c2236_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2249 fn c2237_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2237_l2249_action_invoke"); - let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ge", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17962,7 +22014,13 @@ fn c2237_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2250 fn c2238_l2250_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2238_l2250_action_invoke"); - let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ge", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17970,7 +22028,13 @@ fn c2238_l2250_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2251 fn c2239_l2251_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2239_l2251_action_invoke"); - let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ge", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -17978,7 +22042,13 @@ fn c2239_l2251_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2252 fn c2240_l2252_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2240_l2252_action_invoke"); - let result = instance.call("ge", &[Value::F64((6.283185307179586f64)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ge", + &[ + Value::F64((6.283185307179586f64)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18306,7 +22376,10 @@ fn c2280_l2292_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2293 fn c2281_l2293_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2281_l2293_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))]); + let result = instance.call( + "ge", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18402,7 +22475,10 @@ fn c2292_l2304_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2305 fn c2293_l2305_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2293_l2305_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))]); + let result = instance.call( + "ge", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18434,7 +22510,10 @@ fn c2296_l2308_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2309 fn c2297_l2309_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2297_l2309_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))]); + let result = instance.call( + "ge", + &[Value::F64(f64::NEG_INFINITY), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18466,7 +22545,13 @@ fn c2300_l2312_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2313 fn c2301_l2313_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2301_l2313_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18474,7 +22559,13 @@ fn c2301_l2313_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2314 fn c2302_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2302_l2314_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18482,7 +22573,13 @@ fn c2302_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2315 fn c2303_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2303_l2315_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::INFINITY), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18490,7 +22587,13 @@ fn c2303_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2316 fn c2304_l2316_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2304_l2316_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::INFINITY), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18530,7 +22633,10 @@ fn c2308_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2321 fn c2309_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2309_l2321_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18538,7 +22644,10 @@ fn c2309_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2322 fn c2310_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2310_l2322_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ge", + &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18546,7 +22655,10 @@ fn c2310_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2323 fn c2311_l2323_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2311_l2323_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18554,7 +22666,10 @@ fn c2311_l2323_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2324 fn c2312_l2324_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2312_l2324_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ge", + &[Value::F64(f64::INFINITY), Value::F64(f64::INFINITY)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -18562,7 +22677,13 @@ fn c2312_l2324_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2325 fn c2313_l2325_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2313_l2325_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18570,7 +22691,13 @@ fn c2313_l2325_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2326 fn c2314_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2314_l2326_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18578,7 +22705,13 @@ fn c2314_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2327 fn c2315_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2315_l2327_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18586,7 +22719,13 @@ fn c2315_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2328 fn c2316_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2316_l2328_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18594,7 +22733,13 @@ fn c2316_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2329 fn c2317_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2317_l2329_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18602,7 +22747,13 @@ fn c2317_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2330 fn c2318_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2318_l2330_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18610,7 +22761,13 @@ fn c2318_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2331 fn c2319_l2331_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2319_l2331_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18618,7 +22775,13 @@ fn c2319_l2331_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2332 fn c2320_l2332_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2320_l2332_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::INFINITY), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18626,7 +22789,13 @@ fn c2320_l2332_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2333 fn c2321_l2333_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2321_l2333_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18634,7 +22803,13 @@ fn c2321_l2333_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2334 fn c2322_l2334_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2322_l2334_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18642,7 +22817,13 @@ fn c2322_l2334_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2335 fn c2323_l2335_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2323_l2335_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18650,7 +22831,13 @@ fn c2323_l2335_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2336 fn c2324_l2336_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2324_l2336_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18658,7 +22845,13 @@ fn c2324_l2336_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2337 fn c2325_l2337_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2325_l2337_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18666,7 +22859,13 @@ fn c2325_l2337_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2338 fn c2326_l2338_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2326_l2338_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18674,7 +22873,13 @@ fn c2326_l2338_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2339 fn c2327_l2339_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2327_l2339_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18682,7 +22887,13 @@ fn c2327_l2339_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2340 fn c2328_l2340_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2328_l2340_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18818,7 +23029,13 @@ fn c2344_l2356_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2357 fn c2345_l2357_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2345_l2357_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-0.5f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18826,7 +23043,13 @@ fn c2345_l2357_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2358 fn c2346_l2358_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2346_l2358_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-0.5f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18834,7 +23057,13 @@ fn c2346_l2358_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2359 fn c2347_l2359_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2347_l2359_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((0.5f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18842,7 +23071,13 @@ fn c2347_l2359_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2360 fn c2348_l2360_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2348_l2360_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((0.5f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18850,7 +23085,13 @@ fn c2348_l2360_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2361 fn c2349_l2361_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2349_l2361_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-0.5f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18858,7 +23099,13 @@ fn c2349_l2361_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2362 fn c2350_l2362_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2350_l2362_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-0.5f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18866,7 +23113,13 @@ fn c2350_l2362_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2363 fn c2351_l2363_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2351_l2363_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.5f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18874,7 +23127,13 @@ fn c2351_l2363_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2364 fn c2352_l2364_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2352_l2364_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((0.5f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((0.5f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18882,7 +23141,13 @@ fn c2352_l2364_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2365 fn c2353_l2365_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2353_l2365_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-1.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18890,7 +23155,13 @@ fn c2353_l2365_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2366 fn c2354_l2366_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2354_l2366_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-1.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18898,7 +23169,13 @@ fn c2354_l2366_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2367 fn c2355_l2367_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2355_l2367_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((1.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18906,7 +23183,13 @@ fn c2355_l2367_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2368 fn c2356_l2368_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2356_l2368_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((1.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18914,7 +23197,13 @@ fn c2356_l2368_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2369 fn c2357_l2369_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2357_l2369_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-1.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18922,7 +23211,13 @@ fn c2357_l2369_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2370 fn c2358_l2370_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2358_l2370_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-1.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18930,7 +23225,13 @@ fn c2358_l2370_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2371 fn c2359_l2371_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2359_l2371_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18938,7 +23239,13 @@ fn c2359_l2371_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2372 fn c2360_l2372_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2360_l2372_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((1.0f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18946,7 +23253,13 @@ fn c2360_l2372_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2373 fn c2361_l2373_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2361_l2373_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18954,7 +23267,13 @@ fn c2361_l2373_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2374 fn c2362_l2374_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2362_l2374_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18962,7 +23281,13 @@ fn c2362_l2374_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2375 fn c2363_l2375_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2363_l2375_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18970,7 +23295,13 @@ fn c2363_l2375_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2376 fn c2364_l2376_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2364_l2376_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18978,7 +23309,13 @@ fn c2364_l2376_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2377 fn c2365_l2377_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2365_l2377_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18986,7 +23323,13 @@ fn c2365_l2377_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2378 fn c2366_l2378_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2366_l2378_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((-6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((-6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -18994,7 +23337,13 @@ fn c2366_l2378_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2379 fn c2367_l2379_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2367_l2379_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19002,7 +23351,13 @@ fn c2367_l2379_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2380 fn c2368_l2380_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2368_l2380_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64((6.283185307179586f64))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64((6.283185307179586f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19074,7 +23429,13 @@ fn c2376_l2388_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2389 fn c2377_l2389_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2377_l2389_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19082,7 +23443,13 @@ fn c2377_l2389_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2390 fn c2378_l2390_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2378_l2390_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19090,7 +23457,13 @@ fn c2378_l2390_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2391 fn c2379_l2391_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2379_l2391_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19098,7 +23471,13 @@ fn c2379_l2391_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2392 fn c2380_l2392_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2380_l2392_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19106,7 +23485,13 @@ fn c2380_l2392_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2393 fn c2381_l2393_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2381_l2393_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19114,7 +23499,13 @@ fn c2381_l2393_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2394 fn c2382_l2394_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2382_l2394_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::NEG_INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::NEG_INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19122,7 +23513,13 @@ fn c2382_l2394_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2395 fn c2383_l2395_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2383_l2395_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19130,7 +23527,13 @@ fn c2383_l2395_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2396 fn c2384_l2396_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2384_l2396_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::INFINITY)]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19138,7 +23541,13 @@ fn c2384_l2396_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2397 fn c2385_l2397_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2385_l2397_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19146,7 +23555,13 @@ fn c2385_l2397_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2398 fn c2386_l2398_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2386_l2398_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19154,7 +23569,13 @@ fn c2386_l2398_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2399 fn c2387_l2399_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2387_l2399_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19162,7 +23583,13 @@ fn c2387_l2399_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2400 fn c2388_l2400_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2388_l2400_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19170,7 +23597,13 @@ fn c2388_l2400_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2401 fn c2389_l2401_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2389_l2401_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19178,7 +23611,13 @@ fn c2389_l2401_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2402 fn c2390_l2402_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2390_l2402_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19186,7 +23625,13 @@ fn c2390_l2402_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2403 fn c2391_l2403_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2391_l2403_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18444492273895866368)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19194,7 +23639,13 @@ fn c2391_l2403_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2404 fn c2392_l2404_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2392_l2404_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(18443366373989023744)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19202,7 +23653,13 @@ fn c2392_l2404_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2405 fn c2393_l2405_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2393_l2405_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19210,7 +23667,13 @@ fn c2393_l2405_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2406 fn c2394_l2406_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2394_l2406_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19218,7 +23681,13 @@ fn c2394_l2406_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2407 fn c2395_l2407_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2395_l2407_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19226,7 +23695,13 @@ fn c2395_l2407_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2408 fn c2396_l2408_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2396_l2408_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(18443366373989023744))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(18443366373989023744)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19234,7 +23709,13 @@ fn c2396_l2408_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2409 fn c2397_l2409_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2397_l2409_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19242,7 +23723,13 @@ fn c2397_l2409_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2410 fn c2398_l2410_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2398_l2410_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19250,7 +23737,13 @@ fn c2398_l2410_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2411 fn c2399_l2411_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2399_l2411_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -19258,7 +23751,13 @@ fn c2399_l2411_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2412 fn c2400_l2412_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2400_l2412_action_invoke"); - let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936)), Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "ge", + &[ + Value::F64(f64::from_bits(9219994337134247936)), + Value::F64(f64::from_bits(9219994337134247936)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } diff --git a/lib/runtime/tests/spectests/fac.rs b/lib/runtime/tests/spectests/fac.rs index 744aa2dd8..89b1b6430 100644 --- a/lib/runtime/tests/spectests/fac.rs +++ b/lib/runtime/tests/spectests/fac.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { @@ -136,8 +132,11 @@ fn create_module_1() -> Box { (export \"fac-opt\" (func 4))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { diff --git a/lib/runtime/tests/spectests/float_exprs.rs b/lib/runtime/tests/spectests/float_exprs.rs index fa4f4743a..d292717d8 100644 --- a/lib/runtime/tests/spectests/float_exprs.rs +++ b/lib/runtime/tests/spectests/float_exprs.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 6 fn create_module_1() -> Box { @@ -31,8 +27,11 @@ fn create_module_1() -> Box { (export \"f64.no_contraction\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -60,7 +59,10 @@ fn c2_l12_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c3_l13_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c3_l13_action_invoke"); let result = instance.call("f64.no_contraction", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030119045290520013f64)), Value::F64((52699336439236750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((0.00000000000000000000000000000006654454781339856f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000015872537009936566f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((-0.0000000000000000015872537009936566f64)))) + ); result.map(|_| ()) } @@ -68,7 +70,12 @@ fn c3_l13_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c4_l14_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c4_l14_action_invoke"); let result = instance.call("f64.no_contraction", &[Value::F64((0.0000000000000000000031413936116780743f64)), Value::F64((-0.0000000000000000000000000000007262766035707377f64)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000004619684894228461f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000228152068276836f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.00000000000000000000000000000000000000000000000000228152068276836f64) + ))) + ); result.map(|_| ()) } @@ -113,8 +120,11 @@ fn create_module_2() -> Box { (export \"f64.no_fma\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -125,23 +135,50 @@ fn start_module_2(instance: &mut Instance) { // Line 26 fn c7_l26_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c7_l26_action_invoke"); - let result = instance.call("f32.no_fma", &[Value::F32((35184304000000000000000000000000000000.0f32)), Value::F32((0.00000021584361f32)), Value::F32((259340640000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((266934960000000000000000000000000.0f32))))); + let result = instance.call( + "f32.no_fma", + &[ + Value::F32((35184304000000000000000000000000000000.0f32)), + Value::F32((0.00000021584361f32)), + Value::F32((259340640000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((266934960000000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 27 fn c8_l27_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c8_l27_action_invoke"); - let result = instance.call("f32.no_fma", &[Value::F32((0.0000000071753243f32)), Value::F32((-0.000000000000001225534f32)), Value::F32((0.0000000000000000000000000041316436f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000087894724f32))))); + let result = instance.call( + "f32.no_fma", + &[ + Value::F32((0.0000000071753243f32)), + Value::F32((-0.000000000000001225534f32)), + Value::F32((0.0000000000000000000000000041316436f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-0.0000000000000000000000087894724f32)))) + ); result.map(|_| ()) } // Line 28 fn c9_l28_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c9_l28_action_invoke"); - let result = instance.call("f32.no_fma", &[Value::F32((231063440000.0f32)), Value::F32((0.00020773262f32)), Value::F32((1797.6421f32))]); + let result = instance.call( + "f32.no_fma", + &[ + Value::F32((231063440000.0f32)), + Value::F32((0.00020773262f32)), + Value::F32((1797.6421f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((48001210.0f32))))); result.map(|_| ()) } @@ -149,7 +186,14 @@ fn c9_l28_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 29 fn c10_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c10_l29_action_invoke"); - let result = instance.call("f32.no_fma", &[Value::F32((0.0045542703f32)), Value::F32((-7265493.5f32)), Value::F32((-2.3964283f32))]); + let result = instance.call( + "f32.no_fma", + &[ + Value::F32((0.0045542703f32)), + Value::F32((-7265493.5f32)), + Value::F32((-2.3964283f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-33091.414f32))))); result.map(|_| ()) } @@ -157,7 +201,14 @@ fn c10_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 30 fn c11_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c11_l30_action_invoke"); - let result = instance.call("f32.no_fma", &[Value::F32((98881730000000000000000000000000000000.0f32)), Value::F32((-0.0000000000000000000008570631f32)), Value::F32((-21579143000.0f32))]); + let result = instance.call( + "f32.no_fma", + &[ + Value::F32((98881730000000000000000000000000000000.0f32)), + Value::F32((-0.0000000000000000000008570631f32)), + Value::F32((-21579143000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-84747910000000000.0f32))))); result.map(|_| ()) } @@ -236,8 +287,11 @@ fn create_module_3() -> Box { (export \"f64.no_fold_add_zero\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -263,23 +317,41 @@ fn c19_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 49 fn c20_l49_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c20_l49_assert_return_arithmetic_nan"); - let result = instance.call("f32.no_fold_add_zero", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c20_l49_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c20_l49_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f32.no_fold_add_zero", + &[Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c20_l49_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 50 fn c21_l50_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c21_l50_assert_return_arithmetic_nan"); - let result = instance.call("f64.no_fold_add_zero", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c21_l50_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c21_l50_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f64.no_fold_add_zero", + &[Value::F64(f64::from_bits(9219994337134247936))], + ) + .unwrap() + .expect("Missing result in c21_l50_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -311,8 +383,11 @@ fn create_module_4() -> Box { (export \"f64.no_fold_zero_sub\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { @@ -338,23 +413,41 @@ fn c24_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 63 fn c25_l63_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c25_l63_assert_return_arithmetic_nan"); - let result = instance.call("f32.no_fold_zero_sub", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c25_l63_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c25_l63_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f32.no_fold_zero_sub", + &[Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c25_l63_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 64 fn c26_l64_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c26_l64_assert_return_arithmetic_nan"); - let result = instance.call("f64.no_fold_zero_sub", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c26_l64_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c26_l64_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f64.no_fold_zero_sub", + &[Value::F64(f64::from_bits(9219994337134247936))], + ) + .unwrap() + .expect("Missing result in c26_l64_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -386,8 +479,11 @@ fn create_module_5() -> Box { (export \"f64.no_fold_sub_zero\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_5(instance: &mut Instance) { @@ -397,23 +493,41 @@ fn start_module_5(instance: &mut Instance) { // Line 75 fn c28_l75_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c28_l75_assert_return_arithmetic_nan"); - let result = instance.call("f32.no_fold_sub_zero", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c28_l75_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c28_l75_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f32.no_fold_sub_zero", + &[Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c28_l75_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 76 fn c29_l76_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c29_l76_assert_return_arithmetic_nan"); - let result = instance.call("f64.no_fold_sub_zero", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c29_l76_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c29_l76_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f64.no_fold_sub_zero", + &[Value::F64(f64::from_bits(9219994337134247936))], + ) + .unwrap() + .expect("Missing result in c29_l76_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -443,8 +557,11 @@ fn create_module_6() -> Box { (export \"f64.no_fold_mul_zero\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_6(instance: &mut Instance) { @@ -478,12 +595,21 @@ fn c33_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 90 fn c34_l90_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c34_l90_assert_return_arithmetic_nan"); - let result = instance.call("f32.no_fold_mul_zero", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c34_l90_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c34_l90_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f32.no_fold_mul_zero", + &[Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c34_l90_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -513,12 +639,21 @@ fn c37_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 94 fn c38_l94_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c38_l94_assert_return_arithmetic_nan"); - let result = instance.call("f64.no_fold_mul_zero", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c38_l94_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c38_l94_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f64.no_fold_mul_zero", + &[Value::F64(f64::from_bits(9219994337134247936))], + ) + .unwrap() + .expect("Missing result in c38_l94_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -554,8 +689,11 @@ fn create_module_7() -> Box { (export \"f64.no_fold_mul_one\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_7(instance: &mut Instance) { @@ -565,23 +703,41 @@ fn start_module_7(instance: &mut Instance) { // Line 106 fn c40_l106_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c40_l106_assert_return_arithmetic_nan"); - let result = instance.call("f32.no_fold_mul_one", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c40_l106_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c40_l106_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f32.no_fold_mul_one", + &[Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c40_l106_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 107 fn c41_l107_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c41_l107_assert_return_arithmetic_nan"); - let result = instance.call("f64.no_fold_mul_one", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c41_l107_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c41_l107_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f64.no_fold_mul_one", + &[Value::F64(f64::from_bits(9219994337134247936))], + ) + .unwrap() + .expect("Missing result in c41_l107_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -611,8 +767,11 @@ fn create_module_8() -> Box { (export \"f64.no_fold_zero_div\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_8(instance: &mut Instance) { @@ -622,89 +781,149 @@ fn start_module_8(instance: &mut Instance) { // Line 118 fn c43_l118_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c43_l118_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_zero_div", &[Value::F32((0.0f32))]).unwrap().expect("Missing result in c43_l118_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c43_l118_assert_return_canonical_nan" + ); + let result = instance + .call("f32.no_fold_zero_div", &[Value::F32((0.0f32))]) + .unwrap() + .expect("Missing result in c43_l118_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 119 fn c44_l119_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c44_l119_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_zero_div", &[Value::F32((-0.0f32))]).unwrap().expect("Missing result in c44_l119_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c44_l119_assert_return_canonical_nan" + ); + let result = instance + .call("f32.no_fold_zero_div", &[Value::F32((-0.0f32))]) + .unwrap() + .expect("Missing result in c44_l119_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 120 fn c45_l120_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c45_l120_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_zero_div", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c45_l120_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c45_l120_assert_return_canonical_nan" + ); + let result = instance + .call( + "f32.no_fold_zero_div", + &[Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c45_l120_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 121 fn c46_l121_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c46_l121_assert_return_arithmetic_nan"); - let result = instance.call("f32.no_fold_zero_div", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c46_l121_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c46_l121_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f32.no_fold_zero_div", + &[Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c46_l121_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 122 fn c47_l122_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c47_l122_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_zero_div", &[Value::F64((0.0f64))]).unwrap().expect("Missing result in c47_l122_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c47_l122_assert_return_canonical_nan" + ); + let result = instance + .call("f64.no_fold_zero_div", &[Value::F64((0.0f64))]) + .unwrap() + .expect("Missing result in c47_l122_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 123 fn c48_l123_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c48_l123_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_zero_div", &[Value::F64((-0.0f64))]).unwrap().expect("Missing result in c48_l123_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c48_l123_assert_return_canonical_nan" + ); + let result = instance + .call("f64.no_fold_zero_div", &[Value::F64((-0.0f64))]) + .unwrap() + .expect("Missing result in c48_l123_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 124 fn c49_l124_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c49_l124_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_zero_div", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c49_l124_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c49_l124_assert_return_canonical_nan" + ); + let result = instance + .call( + "f64.no_fold_zero_div", + &[Value::F64(f64::from_bits(9221120237041090560))], + ) + .unwrap() + .expect("Missing result in c49_l124_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 125 fn c50_l125_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c50_l125_assert_return_arithmetic_nan"); - let result = instance.call("f64.no_fold_zero_div", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c50_l125_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c50_l125_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f64.no_fold_zero_div", + &[Value::F64(f64::from_bits(9219994337134247936))], + ) + .unwrap() + .expect("Missing result in c50_l125_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -740,8 +959,11 @@ fn create_module_9() -> Box { (export \"f64.no_fold_div_one\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_9(instance: &mut Instance) { @@ -751,23 +973,41 @@ fn start_module_9(instance: &mut Instance) { // Line 136 fn c52_l136_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c52_l136_assert_return_arithmetic_nan"); - let result = instance.call("f32.no_fold_div_one", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c52_l136_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c52_l136_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f32.no_fold_div_one", + &[Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c52_l136_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 137 fn c53_l137_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c53_l137_assert_return_arithmetic_nan"); - let result = instance.call("f64.no_fold_div_one", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c53_l137_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c53_l137_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f64.no_fold_div_one", + &[Value::F64(f64::from_bits(9219994337134247936))], + ) + .unwrap() + .expect("Missing result in c53_l137_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -797,8 +1037,11 @@ fn create_module_10() -> Box { (export \"f64.no_fold_div_neg1\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_10(instance: &mut Instance) { @@ -808,23 +1051,41 @@ fn start_module_10(instance: &mut Instance) { // Line 148 fn c55_l148_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c55_l148_assert_return_arithmetic_nan"); - let result = instance.call("f32.no_fold_div_neg1", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c55_l148_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c55_l148_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f32.no_fold_div_neg1", + &[Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c55_l148_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 149 fn c56_l149_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c56_l149_assert_return_arithmetic_nan"); - let result = instance.call("f64.no_fold_div_neg1", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c56_l149_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c56_l149_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f64.no_fold_div_neg1", + &[Value::F64(f64::from_bits(9219994337134247936))], + ) + .unwrap() + .expect("Missing result in c56_l149_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -854,8 +1115,11 @@ fn create_module_11() -> Box { (export \"f64.no_fold_neg0_sub\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_11(instance: &mut Instance) { @@ -865,23 +1129,41 @@ fn start_module_11(instance: &mut Instance) { // Line 160 fn c58_l160_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c58_l160_assert_return_arithmetic_nan"); - let result = instance.call("f32.no_fold_neg0_sub", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c58_l160_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c58_l160_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f32.no_fold_neg0_sub", + &[Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c58_l160_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 161 fn c59_l161_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c59_l161_assert_return_arithmetic_nan"); - let result = instance.call("f64.no_fold_neg0_sub", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c59_l161_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c59_l161_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f64.no_fold_neg0_sub", + &[Value::F64(f64::from_bits(9219994337134247936))], + ) + .unwrap() + .expect("Missing result in c59_l161_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -911,8 +1193,11 @@ fn create_module_12() -> Box { (export \"f64.no_fold_neg1_mul\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_12(instance: &mut Instance) { @@ -922,23 +1207,41 @@ fn start_module_12(instance: &mut Instance) { // Line 172 fn c61_l172_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c61_l172_assert_return_arithmetic_nan"); - let result = instance.call("f32.no_fold_neg1_mul", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c61_l172_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c61_l172_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f32.no_fold_neg1_mul", + &[Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c61_l172_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 173 fn c62_l173_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c62_l173_assert_return_arithmetic_nan"); - let result = instance.call("f64.no_fold_neg1_mul", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c62_l173_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c62_l173_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f64.no_fold_neg1_mul", + &[Value::F64(f64::from_bits(9219994337134247936))], + ) + .unwrap() + .expect("Missing result in c62_l173_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -968,8 +1271,11 @@ fn create_module_13() -> Box { (export \"f64.no_fold_eq_self\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_13(instance: &mut Instance) { @@ -980,7 +1286,10 @@ fn start_module_13(instance: &mut Instance) { // Line 184 fn c64_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c64_l184_action_invoke"); - let result = instance.call("f32.no_fold_eq_self", &[Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_fold_eq_self", + &[Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -988,7 +1297,10 @@ fn c64_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 185 fn c65_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c65_l185_action_invoke"); - let result = instance.call("f64.no_fold_eq_self", &[Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_fold_eq_self", + &[Value::F64(f64::from_bits(9221120237041090560))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1019,8 +1331,11 @@ fn create_module_14() -> Box { (export \"f64.no_fold_ne_self\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_14(instance: &mut Instance) { @@ -1031,7 +1346,10 @@ fn start_module_14(instance: &mut Instance) { // Line 196 fn c67_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c67_l196_action_invoke"); - let result = instance.call("f32.no_fold_ne_self", &[Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_fold_ne_self", + &[Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1039,7 +1357,10 @@ fn c67_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 197 fn c68_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c68_l197_action_invoke"); - let result = instance.call("f64.no_fold_ne_self", &[Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_fold_ne_self", + &[Value::F64(f64::from_bits(9221120237041090560))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1070,8 +1391,11 @@ fn create_module_15() -> Box { (export \"f64.no_fold_sub_self\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_15(instance: &mut Instance) { @@ -1081,45 +1405,75 @@ fn start_module_15(instance: &mut Instance) { // Line 208 fn c70_l208_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c70_l208_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_sub_self", &[Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c70_l208_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c70_l208_assert_return_canonical_nan" + ); + let result = instance + .call("f32.no_fold_sub_self", &[Value::F32(f32::INFINITY)]) + .unwrap() + .expect("Missing result in c70_l208_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 209 fn c71_l209_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c71_l209_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_sub_self", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c71_l209_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c71_l209_assert_return_canonical_nan" + ); + let result = instance + .call( + "f32.no_fold_sub_self", + &[Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c71_l209_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 210 fn c72_l210_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c72_l210_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_sub_self", &[Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c72_l210_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c72_l210_assert_return_canonical_nan" + ); + let result = instance + .call("f64.no_fold_sub_self", &[Value::F64(f64::INFINITY)]) + .unwrap() + .expect("Missing result in c72_l210_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 211 fn c73_l211_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c73_l211_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_sub_self", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c73_l211_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c73_l211_assert_return_canonical_nan" + ); + let result = instance + .call( + "f64.no_fold_sub_self", + &[Value::F64(f64::from_bits(9221120237041090560))], + ) + .unwrap() + .expect("Missing result in c73_l211_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -1151,8 +1505,11 @@ fn create_module_16() -> Box { (export \"f64.no_fold_div_self\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_16(instance: &mut Instance) { @@ -1162,89 +1519,143 @@ fn start_module_16(instance: &mut Instance) { // Line 222 fn c75_l222_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c75_l222_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_div_self", &[Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c75_l222_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c75_l222_assert_return_canonical_nan" + ); + let result = instance + .call("f32.no_fold_div_self", &[Value::F32(f32::INFINITY)]) + .unwrap() + .expect("Missing result in c75_l222_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 223 fn c76_l223_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c76_l223_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_div_self", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c76_l223_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c76_l223_assert_return_canonical_nan" + ); + let result = instance + .call( + "f32.no_fold_div_self", + &[Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c76_l223_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 224 fn c77_l224_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c77_l224_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_div_self", &[Value::F32((0.0f32))]).unwrap().expect("Missing result in c77_l224_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c77_l224_assert_return_canonical_nan" + ); + let result = instance + .call("f32.no_fold_div_self", &[Value::F32((0.0f32))]) + .unwrap() + .expect("Missing result in c77_l224_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 225 fn c78_l225_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c78_l225_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_div_self", &[Value::F32((-0.0f32))]).unwrap().expect("Missing result in c78_l225_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c78_l225_assert_return_canonical_nan" + ); + let result = instance + .call("f32.no_fold_div_self", &[Value::F32((-0.0f32))]) + .unwrap() + .expect("Missing result in c78_l225_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 226 fn c79_l226_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c79_l226_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_div_self", &[Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c79_l226_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c79_l226_assert_return_canonical_nan" + ); + let result = instance + .call("f64.no_fold_div_self", &[Value::F64(f64::INFINITY)]) + .unwrap() + .expect("Missing result in c79_l226_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 227 fn c80_l227_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c80_l227_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_div_self", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c80_l227_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c80_l227_assert_return_canonical_nan" + ); + let result = instance + .call( + "f64.no_fold_div_self", + &[Value::F64(f64::from_bits(9221120237041090560))], + ) + .unwrap() + .expect("Missing result in c80_l227_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 228 fn c81_l228_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c81_l228_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_div_self", &[Value::F64((0.0f64))]).unwrap().expect("Missing result in c81_l228_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c81_l228_assert_return_canonical_nan" + ); + let result = instance + .call("f64.no_fold_div_self", &[Value::F64((0.0f64))]) + .unwrap() + .expect("Missing result in c81_l228_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 229 fn c82_l229_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c82_l229_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_div_self", &[Value::F64((-0.0f64))]).unwrap().expect("Missing result in c82_l229_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c82_l229_assert_return_canonical_nan" + ); + let result = instance + .call("f64.no_fold_div_self", &[Value::F64((-0.0f64))]) + .unwrap() + .expect("Missing result in c82_l229_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -1280,8 +1691,11 @@ fn create_module_17() -> Box { (export \"f64.no_fold_div_3\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_17(instance: &mut Instance) { @@ -1300,32 +1714,60 @@ fn c84_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 241 fn c85_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c85_l241_action_invoke"); - let result = instance.call("f32.no_fold_div_3", &[Value::F32((-18736880000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-6245626600000000000000000000.0f32))))); + let result = instance.call( + "f32.no_fold_div_3", + &[Value::F32((-18736880000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-6245626600000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 242 fn c86_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c86_l242_action_invoke"); - let result = instance.call("f32.no_fold_div_3", &[Value::F32((-0.00000000000000000000000012045131f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000040150435f32))))); + let result = instance.call( + "f32.no_fold_div_3", + &[Value::F32((-0.00000000000000000000000012045131f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-0.000000000000000000000000040150435f32)))) + ); result.map(|_| ()) } // Line 243 fn c87_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c87_l243_action_invoke"); - let result = instance.call("f32.no_fold_div_3", &[Value::F32((-0.00000000000000000000000000000000000005281346f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000017604486f32))))); + let result = instance.call( + "f32.no_fold_div_3", + &[Value::F32( + (-0.00000000000000000000000000000000000005281346f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000017604486f32) + ))) + ); result.map(|_| ()) } // Line 244 fn c88_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c88_l244_action_invoke"); - let result = instance.call("f32.no_fold_div_3", &[Value::F32((-0.000000000000000025495563f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000008498521f32))))); + let result = instance.call( + "f32.no_fold_div_3", + &[Value::F32((-0.000000000000000025495563f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-0.000000000000000008498521f32)))) + ); result.map(|_| ()) } @@ -1340,8 +1782,18 @@ fn c89_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 246 fn c90_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c90_l246_action_invoke"); - let result = instance.call("f64.no_fold_div_3", &[Value::F64((-0.000000000000000000000000000000000000000000000000009291150921449772f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000003097050307149924f64))))); + let result = instance.call( + "f64.no_fold_div_3", + &[Value::F64( + (-0.000000000000000000000000000000000000000000000000009291150921449772f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.000000000000000000000000000000000000000000000000003097050307149924f64) + ))) + ); result.map(|_| ()) } @@ -1411,8 +1863,11 @@ fn create_module_18() -> Box { (export \"f64.no_factor\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_18(instance: &mut Instance) { @@ -1423,15 +1878,32 @@ fn start_module_18(instance: &mut Instance) { // Line 260 fn c95_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c95_l260_action_invoke"); - let result = instance.call("f32.no_factor", &[Value::F32((-1435111700000.0f32)), Value::F32((-853617640000000.0f32)), Value::F32((1113849300000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-952399900000000000000000000000000.0f32))))); + let result = instance.call( + "f32.no_factor", + &[ + Value::F32((-1435111700000.0f32)), + Value::F32((-853617640000000.0f32)), + Value::F32((1113849300000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-952399900000000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 261 fn c96_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c96_l261_action_invoke"); - let result = instance.call("f32.no_factor", &[Value::F32((-0.026666632f32)), Value::F32((0.048412822f32)), Value::F32((-0.002813697f32))]); + let result = instance.call( + "f32.no_factor", + &[ + Value::F32((-0.026666632f32)), + Value::F32((0.048412822f32)), + Value::F32((-0.002813697f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0000611872f32))))); result.map(|_| ()) } @@ -1439,15 +1911,32 @@ fn c96_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 262 fn c97_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c97_l262_action_invoke"); - let result = instance.call("f32.no_factor", &[Value::F32((-0.00000000000046619777f32)), Value::F32((0.00000000000000000010478377f32)), Value::F32((14469202000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-6745508000000000000000000.0f32))))); + let result = instance.call( + "f32.no_factor", + &[ + Value::F32((-0.00000000000046619777f32)), + Value::F32((0.00000000000000000010478377f32)), + Value::F32((14469202000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-6745508000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 263 fn c98_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c98_l263_action_invoke"); - let result = instance.call("f32.no_factor", &[Value::F32((-0.00000000000000000010689046f32)), Value::F32((0.00000000000000000000000010694433f32)), Value::F32((568307000000000000000000000000000000.0f32))]); + let result = instance.call( + "f32.no_factor", + &[ + Value::F32((-0.00000000000000000010689046f32)), + Value::F32((0.00000000000000000000000010694433f32)), + Value::F32((568307000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-60746540000000000.0f32))))); result.map(|_| ()) } @@ -1455,7 +1944,14 @@ fn c98_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 264 fn c99_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c99_l264_action_invoke"); - let result = instance.call("f32.no_factor", &[Value::F32((-0.000000000000000000000000063545994f32)), Value::F32((0.0000000000000000000007524625f32)), Value::F32((1626770.3f32))]); + let result = instance.call( + "f32.no_factor", + &[ + Value::F32((-0.000000000000000000000000063545994f32)), + Value::F32((0.0000000000000000000007524625f32)), + Value::F32((1626770.3f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0000000000000012239803f32))))); result.map(|_| ()) } @@ -1480,7 +1976,12 @@ fn c101_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c102_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c102_l267_action_invoke"); let result = instance.call("f64.no_factor", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002939056292080733f64)), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000002146156743463356f64)), Value::F64((-2510967223130241600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((538892923853642600000000000000000000000000000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (538892923853642600000000000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -1496,7 +1997,12 @@ fn c103_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c104_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c104_l269_action_invoke"); let result = instance.call("f64.no_factor", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015194859063177362f64)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000883589921438065f64)), Value::F64((-1735830019469195800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000015337619131701908f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.0000000000000000000000000015337619131701908f64) + ))) + ); result.map(|_| ()) } @@ -1538,8 +2044,11 @@ fn create_module_19() -> Box { (export \"f64.no_distribute\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_19(instance: &mut Instance) { @@ -1550,15 +2059,32 @@ fn start_module_19(instance: &mut Instance) { // Line 280 fn c106_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c106_l280_action_invoke"); - let result = instance.call("f32.no_distribute", &[Value::F32((-1435111700000.0f32)), Value::F32((-853617640000000.0f32)), Value::F32((1113849300000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-952400000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.no_distribute", + &[ + Value::F32((-1435111700000.0f32)), + Value::F32((-853617640000000.0f32)), + Value::F32((1113849300000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-952400000000000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 281 fn c107_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c107_l281_action_invoke"); - let result = instance.call("f32.no_distribute", &[Value::F32((-0.026666632f32)), Value::F32((0.048412822f32)), Value::F32((-0.002813697f32))]); + let result = instance.call( + "f32.no_distribute", + &[ + Value::F32((-0.026666632f32)), + Value::F32((0.048412822f32)), + Value::F32((-0.002813697f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.000061187195f32))))); result.map(|_| ()) } @@ -1566,15 +2092,32 @@ fn c107_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 282 fn c108_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c108_l282_action_invoke"); - let result = instance.call("f32.no_distribute", &[Value::F32((-0.00000000000046619777f32)), Value::F32((0.00000000000000000010478377f32)), Value::F32((14469202000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-6745508500000000000000000.0f32))))); + let result = instance.call( + "f32.no_distribute", + &[ + Value::F32((-0.00000000000046619777f32)), + Value::F32((0.00000000000000000010478377f32)), + Value::F32((14469202000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-6745508500000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 283 fn c109_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c109_l283_action_invoke"); - let result = instance.call("f32.no_distribute", &[Value::F32((-0.00000000000000000010689046f32)), Value::F32((0.00000000000000000000000010694433f32)), Value::F32((568307000000000000000000000000000000.0f32))]); + let result = instance.call( + "f32.no_distribute", + &[ + Value::F32((-0.00000000000000000010689046f32)), + Value::F32((0.00000000000000000000000010694433f32)), + Value::F32((568307000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-60746536000000000.0f32))))); result.map(|_| ()) } @@ -1582,7 +2125,14 @@ fn c109_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 284 fn c110_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c110_l284_action_invoke"); - let result = instance.call("f32.no_distribute", &[Value::F32((-0.000000000000000000000000063545994f32)), Value::F32((0.0000000000000000000007524625f32)), Value::F32((1626770.3f32))]); + let result = instance.call( + "f32.no_distribute", + &[ + Value::F32((-0.000000000000000000000000063545994f32)), + Value::F32((0.0000000000000000000007524625f32)), + Value::F32((1626770.3f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0000000000000012239802f32))))); result.map(|_| ()) } @@ -1607,7 +2157,12 @@ fn c112_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c113_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c113_l287_action_invoke"); let result = instance.call("f64.no_distribute", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002939056292080733f64)), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000002146156743463356f64)), Value::F64((-2510967223130241600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((538892923853642500000000000000000000000000000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (538892923853642500000000000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -1623,7 +2178,12 @@ fn c114_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c115_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c115_l289_action_invoke"); let result = instance.call("f64.no_distribute", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015194859063177362f64)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000883589921438065f64)), Value::F64((-1735830019469195800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000015337619131701907f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.0000000000000000000000000015337619131701907f64) + ))) + ); result.map(|_| ()) } @@ -1665,8 +2225,11 @@ fn create_module_20() -> Box { (export \"f64.no_regroup_div_mul\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_20(instance: &mut Instance) { @@ -1677,15 +2240,32 @@ fn start_module_20(instance: &mut Instance) { // Line 300 fn c117_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c117_l300_action_invoke"); - let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((-0.00000000000000000000000000000000002831349f32)), Value::F32((-0.00000000000000000007270787f32)), Value::F32((0.000000000000000000000000000000000016406605f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000012547468f32))))); + let result = instance.call( + "f32.no_regroup_div_mul", + &[ + Value::F32((-0.00000000000000000000000000000000002831349f32)), + Value::F32((-0.00000000000000000007270787f32)), + Value::F32((0.000000000000000000000000000000000016406605f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.00000000000000000012547468f32)))) + ); result.map(|_| ()) } // Line 301 fn c118_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c118_l301_action_invoke"); - let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((-3145897700000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000040864003f32)), Value::F32((-9245928300000000000000.0f32))]); + let result = instance.call( + "f32.no_regroup_div_mul", + &[ + Value::F32((-3145897700000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000040864003f32)), + Value::F32((-9245928300000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -1693,23 +2273,52 @@ fn c118_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 302 fn c119_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c119_l302_action_invoke"); - let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((-93157.43f32)), Value::F32((-0.00000081292654f32)), Value::F32((-0.00000000000000000000000000000000000015469397f32))]); - assert_eq!(result, Ok(Some(Value::F32((-489548120000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.no_regroup_div_mul", + &[ + Value::F32((-93157.43f32)), + Value::F32((-0.00000081292654f32)), + Value::F32((-0.00000000000000000000000000000000000015469397f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-489548120000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 303 fn c120_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c120_l303_action_invoke"); - let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((-0.00000000000000000000000000008899643f32)), Value::F32((17887725000000000000000.0f32)), Value::F32((514680230000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000003093073f32))))); + let result = instance.call( + "f32.no_regroup_div_mul", + &[ + Value::F32((-0.00000000000000000000000000008899643f32)), + Value::F32((17887725000000000000000.0f32)), + Value::F32((514680230000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-0.000000000000000000000000003093073f32)))) + ); result.map(|_| ()) } // Line 304 fn c121_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c121_l304_action_invoke"); - let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((9222036000000000000000000000000000.0f32)), Value::F32((33330492.0f32)), Value::F32((-3253108800000000000000.0f32))]); + let result = instance.call( + "f32.no_regroup_div_mul", + &[ + Value::F32((9222036000000000000000000000000000.0f32)), + Value::F32((33330492.0f32)), + Value::F32((-3253108800000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-94486550000000000000.0f32))))); result.map(|_| ()) } @@ -1718,7 +2327,10 @@ fn c121_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c122_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c122_l305_action_invoke"); let result = instance.call("f64.no_regroup_div_mul", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005698811412550059f64)), Value::F64((-0.0000000000000000000000000000000000018313439132919336f64)), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009543270551003098f64))]); - assert_eq!(result, Ok(Some(Value::F64((-1093596114413331000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((-1093596114413331000000000000000.0f64)))) + ); result.map(|_| ()) } @@ -1742,7 +2354,12 @@ fn c124_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c125_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c125_l308_action_invoke"); let result = instance.call("f64.no_regroup_div_mul", &[Value::F64((-4492093000352015000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((-12087878984017852000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((-596613380626062300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-91013507803376260000000000000000000000000000000000000000000000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (-91013507803376260000000000000000000000000000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -1792,8 +2409,11 @@ fn create_module_21() -> Box { (export \"f64.no_regroup_mul_div\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_21(instance: &mut Instance) { @@ -1804,7 +2424,14 @@ fn start_module_21(instance: &mut Instance) { // Line 320 fn c128_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c128_l320_action_invoke"); - let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((-0.00000000000000000000000000000000002831349f32)), Value::F32((-0.00000000000000000007270787f32)), Value::F32((0.000000000000000000000000000000000016406605f32))]); + let result = instance.call( + "f32.no_regroup_mul_div", + &[ + Value::F32((-0.00000000000000000000000000000000002831349f32)), + Value::F32((-0.00000000000000000007270787f32)), + Value::F32((0.000000000000000000000000000000000016406605f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -1812,31 +2439,72 @@ fn c128_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 321 fn c129_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c129_l321_action_invoke"); - let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((-3145897700000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000040864003f32)), Value::F32((-9245928300000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000013903848f32))))); + let result = instance.call( + "f32.no_regroup_mul_div", + &[ + Value::F32((-3145897700000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000040864003f32)), + Value::F32((-9245928300000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000013903848f32) + ))) + ); result.map(|_| ()) } // Line 322 fn c130_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c130_l322_action_invoke"); - let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((-93157.43f32)), Value::F32((-0.00000081292654f32)), Value::F32((-0.00000000000000000000000000000000000015469397f32))]); - assert_eq!(result, Ok(Some(Value::F32((-489548160000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.no_regroup_mul_div", + &[ + Value::F32((-93157.43f32)), + Value::F32((-0.00000081292654f32)), + Value::F32((-0.00000000000000000000000000000000000015469397f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-489548160000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 323 fn c131_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c131_l323_action_invoke"); - let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((-0.00000000000000000000000000008899643f32)), Value::F32((17887725000000000000000.0f32)), Value::F32((514680230000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000000030930732f32))))); + let result = instance.call( + "f32.no_regroup_mul_div", + &[ + Value::F32((-0.00000000000000000000000000008899643f32)), + Value::F32((17887725000000000000000.0f32)), + Value::F32((514680230000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-0.0000000000000000000000000030930732f32)))) + ); result.map(|_| ()) } // Line 324 fn c132_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c132_l324_action_invoke"); - let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((9222036000000000000000000000000000.0f32)), Value::F32((33330492.0f32)), Value::F32((-3253108800000000000000.0f32))]); + let result = instance.call( + "f32.no_regroup_mul_div", + &[ + Value::F32((9222036000000000000000000000000000.0f32)), + Value::F32((33330492.0f32)), + Value::F32((-3253108800000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -1845,7 +2513,10 @@ fn c132_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c133_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c133_l325_action_invoke"); let result = instance.call("f64.no_regroup_mul_div", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005698811412550059f64)), Value::F64((-0.0000000000000000000000000000000000018313439132919336f64)), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009543270551003098f64))]); - assert_eq!(result, Ok(Some(Value::F64((-1093596114413331100000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((-1093596114413331100000000000000.0f64)))) + ); result.map(|_| ()) } @@ -1923,8 +2594,11 @@ fn create_module_22() -> Box { (export \"f64.no_reassociate_add\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_22(instance: &mut Instance) { @@ -1935,7 +2609,15 @@ fn start_module_22(instance: &mut Instance) { // Line 340 fn c139_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c139_l340_action_invoke"); - let result = instance.call("f32.no_reassociate_add", &[Value::F32((-24154321000000.0f32)), Value::F32((26125812000.0f32)), Value::F32((-238608080000000.0f32)), Value::F32((-2478953500000.0f32))]); + let result = instance.call( + "f32.no_reassociate_add", + &[ + Value::F32((-24154321000000.0f32)), + Value::F32((26125812000.0f32)), + Value::F32((-238608080000000.0f32)), + Value::F32((-2478953500000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-265215220000000.0f32))))); result.map(|_| ()) } @@ -1943,7 +2625,15 @@ fn c139_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 341 fn c140_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c140_l341_action_invoke"); - let result = instance.call("f32.no_reassociate_add", &[Value::F32((0.0036181053f32)), Value::F32((-0.00985944f32)), Value::F32((0.063375376f32)), Value::F32((-0.011150199f32))]); + let result = instance.call( + "f32.no_reassociate_add", + &[ + Value::F32((0.0036181053f32)), + Value::F32((-0.00985944f32)), + Value::F32((0.063375376f32)), + Value::F32((-0.011150199f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.04598384f32))))); result.map(|_| ()) } @@ -1951,7 +2641,15 @@ fn c140_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 342 fn c141_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c141_l342_action_invoke"); - let result = instance.call("f32.no_reassociate_add", &[Value::F32((-34206968000.0f32)), Value::F32((-3770877200000.0f32)), Value::F32((30868425000000.0f32)), Value::F32((421132080000.0f32))]); + let result = instance.call( + "f32.no_reassociate_add", + &[ + Value::F32((-34206968000.0f32)), + Value::F32((-3770877200000.0f32)), + Value::F32((30868425000000.0f32)), + Value::F32((421132080000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((27484470000000.0f32))))); result.map(|_| ()) } @@ -1959,7 +2657,15 @@ fn c141_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 343 fn c142_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c142_l343_action_invoke"); - let result = instance.call("f32.no_reassociate_add", &[Value::F32((153506400000000.0f32)), Value::F32((925114700000000.0f32)), Value::F32((-36021854000.0f32)), Value::F32((2450846000000000.0f32))]); + let result = instance.call( + "f32.no_reassociate_add", + &[ + Value::F32((153506400000000.0f32)), + Value::F32((925114700000000.0f32)), + Value::F32((-36021854000.0f32)), + Value::F32((2450846000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((3529431000000000.0f32))))); result.map(|_| ()) } @@ -1967,8 +2673,19 @@ fn c142_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 344 fn c143_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c143_l344_action_invoke"); - let result = instance.call("f32.no_reassociate_add", &[Value::F32((470600300000000000000000000000000.0f32)), Value::F32((-396552040000000000000000000000000.0f32)), Value::F32((48066940000000000000000000000000.0f32)), Value::F32((-35644073000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((122079560000000000000000000000000.0f32))))); + let result = instance.call( + "f32.no_reassociate_add", + &[ + Value::F32((470600300000000000000000000000000.0f32)), + Value::F32((-396552040000000000000000000000000.0f32)), + Value::F32((48066940000000000000000000000000.0f32)), + Value::F32((-35644073000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((122079560000000000000000000000000.0f32)))) + ); result.map(|_| ()) } @@ -2054,8 +2771,11 @@ fn create_module_23() -> Box { (export \"f64.no_reassociate_mul\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_23(instance: &mut Instance) { @@ -2066,15 +2786,36 @@ fn start_module_23(instance: &mut Instance) { // Line 360 fn c150_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c150_l360_action_invoke"); - let result = instance.call("f32.no_reassociate_mul", &[Value::F32((0.00000000000000000000000000000000001904515f32)), Value::F32((0.00000000022548861f32)), Value::F32((-6964322000000000000000000000000.0f32)), Value::F32((0.000000000000000026902832f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000078764173f32))))); + let result = instance.call( + "f32.no_reassociate_mul", + &[ + Value::F32((0.00000000000000000000000000000000001904515f32)), + Value::F32((0.00000000022548861f32)), + Value::F32((-6964322000000000000000000000000.0f32)), + Value::F32((0.000000000000000026902832f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.00000000000000000000000000000078764173f32) + ))) + ); result.map(|_| ()) } // Line 361 fn c151_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c151_l361_action_invoke"); - let result = instance.call("f32.no_reassociate_mul", &[Value::F32((0.000000000000000018733125f32)), Value::F32((-7565904000000000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000000000000030807684f32)), Value::F32((-1592759200000000000000.0f32))]); + let result = instance.call( + "f32.no_reassociate_mul", + &[ + Value::F32((0.000000000000000018733125f32)), + Value::F32((-7565904000000000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000000000000030807684f32)), + Value::F32((-1592759200000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0069547286f32))))); result.map(|_| ()) } @@ -2082,7 +2823,15 @@ fn c151_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 362 fn c152_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c152_l362_action_invoke"); - let result = instance.call("f32.no_reassociate_mul", &[Value::F32((0.0000000000000050355575f32)), Value::F32((-56466884000000000.0f32)), Value::F32((-0.0000000000011740512f32)), Value::F32((84984730000000000000000.0f32))]); + let result = instance.call( + "f32.no_reassociate_mul", + &[ + Value::F32((0.0000000000000050355575f32)), + Value::F32((-56466884000000000.0f32)), + Value::F32((-0.0000000000011740512f32)), + Value::F32((84984730000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((28370654000000.0f32))))); result.map(|_| ()) } @@ -2090,16 +2839,38 @@ fn c152_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 363 fn c153_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c153_l363_action_invoke"); - let result = instance.call("f32.no_reassociate_mul", &[Value::F32((0.000000000000000000000000000000046394946f32)), Value::F32((254449360000000000000000.0f32)), Value::F32((-72460980000000000.0f32)), Value::F32((-962511040000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((823345100000000000000000000.0f32))))); + let result = instance.call( + "f32.no_reassociate_mul", + &[ + Value::F32((0.000000000000000000000000000000046394946f32)), + Value::F32((254449360000000000000000.0f32)), + Value::F32((-72460980000000000.0f32)), + Value::F32((-962511040000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((823345100000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 364 fn c154_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c154_l364_action_invoke"); - let result = instance.call("f32.no_reassociate_mul", &[Value::F32((-0.0000000000000000000000000000019420536f32)), Value::F32((0.0000000000000023200355f32)), Value::F32((-9.772748f32)), Value::F32((864066000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000035113616f32))))); + let result = instance.call( + "f32.no_reassociate_mul", + &[ + Value::F32((-0.0000000000000000000000000000019420536f32)), + Value::F32((0.0000000000000023200355f32)), + Value::F32((-9.772748f32)), + Value::F32((864066000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.000000000000000000000000035113616f32)))) + ); result.map(|_| ()) } @@ -2177,8 +2948,11 @@ fn create_module_24() -> Box { (export \"f64.no_fold_div_0\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_24(instance: &mut Instance) { @@ -2220,45 +2994,75 @@ fn c164_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 384 fn c165_l384_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c165_l384_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_div_0", &[Value::F32((0.0f32))]).unwrap().expect("Missing result in c165_l384_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c165_l384_assert_return_canonical_nan" + ); + let result = instance + .call("f32.no_fold_div_0", &[Value::F32((0.0f32))]) + .unwrap() + .expect("Missing result in c165_l384_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 385 fn c166_l385_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c166_l385_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_div_0", &[Value::F32((-0.0f32))]).unwrap().expect("Missing result in c166_l385_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c166_l385_assert_return_canonical_nan" + ); + let result = instance + .call("f32.no_fold_div_0", &[Value::F32((-0.0f32))]) + .unwrap() + .expect("Missing result in c166_l385_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 386 fn c167_l386_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c167_l386_assert_return_arithmetic_nan"); - let result = instance.call("f32.no_fold_div_0", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c167_l386_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c167_l386_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f32.no_fold_div_0", + &[Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c167_l386_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 387 fn c168_l387_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c168_l387_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_div_0", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c168_l387_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c168_l387_assert_return_canonical_nan" + ); + let result = instance + .call( + "f32.no_fold_div_0", + &[Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c168_l387_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -2296,45 +3100,75 @@ fn c172_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 392 fn c173_l392_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c173_l392_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_div_0", &[Value::F64((0.0f64))]).unwrap().expect("Missing result in c173_l392_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c173_l392_assert_return_canonical_nan" + ); + let result = instance + .call("f64.no_fold_div_0", &[Value::F64((0.0f64))]) + .unwrap() + .expect("Missing result in c173_l392_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 393 fn c174_l393_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c174_l393_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_div_0", &[Value::F64((-0.0f64))]).unwrap().expect("Missing result in c174_l393_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c174_l393_assert_return_canonical_nan" + ); + let result = instance + .call("f64.no_fold_div_0", &[Value::F64((-0.0f64))]) + .unwrap() + .expect("Missing result in c174_l393_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 394 fn c175_l394_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c175_l394_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_div_0", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c175_l394_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c175_l394_assert_return_canonical_nan" + ); + let result = instance + .call( + "f64.no_fold_div_0", + &[Value::F64(f64::from_bits(9221120237041090560))], + ) + .unwrap() + .expect("Missing result in c175_l394_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 395 fn c176_l395_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c176_l395_assert_return_arithmetic_nan"); - let result = instance.call("f64.no_fold_div_0", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c176_l395_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c176_l395_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f64.no_fold_div_0", + &[Value::F64(f64::from_bits(9219994337134247936))], + ) + .unwrap() + .expect("Missing result in c176_l395_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -2378,8 +3212,11 @@ fn create_module_25() -> Box { (export \"f64.no_fold_div_neg0\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_25(instance: &mut Instance) { @@ -2421,45 +3258,75 @@ fn c181_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 410 fn c182_l410_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c182_l410_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_div_neg0", &[Value::F32((0.0f32))]).unwrap().expect("Missing result in c182_l410_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c182_l410_assert_return_canonical_nan" + ); + let result = instance + .call("f32.no_fold_div_neg0", &[Value::F32((0.0f32))]) + .unwrap() + .expect("Missing result in c182_l410_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 411 fn c183_l411_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c183_l411_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_div_neg0", &[Value::F32((-0.0f32))]).unwrap().expect("Missing result in c183_l411_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c183_l411_assert_return_canonical_nan" + ); + let result = instance + .call("f32.no_fold_div_neg0", &[Value::F32((-0.0f32))]) + .unwrap() + .expect("Missing result in c183_l411_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 412 fn c184_l412_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c184_l412_assert_return_arithmetic_nan"); - let result = instance.call("f32.no_fold_div_neg0", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c184_l412_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c184_l412_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f32.no_fold_div_neg0", + &[Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c184_l412_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 413 fn c185_l413_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c185_l413_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_div_neg0", &[Value::F32(f32::from_bits(2143289344))]).unwrap().expect("Missing result in c185_l413_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c185_l413_assert_return_canonical_nan" + ); + let result = instance + .call( + "f32.no_fold_div_neg0", + &[Value::F32(f32::from_bits(2143289344))], + ) + .unwrap() + .expect("Missing result in c185_l413_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -2497,45 +3364,75 @@ fn c189_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 418 fn c190_l418_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c190_l418_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_div_neg0", &[Value::F64((0.0f64))]).unwrap().expect("Missing result in c190_l418_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c190_l418_assert_return_canonical_nan" + ); + let result = instance + .call("f64.no_fold_div_neg0", &[Value::F64((0.0f64))]) + .unwrap() + .expect("Missing result in c190_l418_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 419 fn c191_l419_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c191_l419_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_div_neg0", &[Value::F64((-0.0f64))]).unwrap().expect("Missing result in c191_l419_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c191_l419_assert_return_canonical_nan" + ); + let result = instance + .call("f64.no_fold_div_neg0", &[Value::F64((-0.0f64))]) + .unwrap() + .expect("Missing result in c191_l419_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 420 fn c192_l420_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c192_l420_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_div_neg0", &[Value::F64(f64::from_bits(9221120237041090560))]).unwrap().expect("Missing result in c192_l420_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c192_l420_assert_return_canonical_nan" + ); + let result = instance + .call( + "f64.no_fold_div_neg0", + &[Value::F64(f64::from_bits(9221120237041090560))], + ) + .unwrap() + .expect("Missing result in c192_l420_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 421 fn c193_l421_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c193_l421_assert_return_arithmetic_nan"); - let result = instance.call("f64.no_fold_div_neg0", &[Value::F64(f64::from_bits(9219994337134247936))]).unwrap().expect("Missing result in c193_l421_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c193_l421_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "f64.no_fold_div_neg0", + &[Value::F64(f64::from_bits(9219994337134247936))], + ) + .unwrap() + .expect("Missing result in c193_l421_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -2589,8 +3486,11 @@ fn create_module_26() -> Box { (export \"f64.no_fold_to_hypot\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_26(instance: &mut Instance) { @@ -2601,31 +3501,61 @@ fn start_module_26(instance: &mut Instance) { // Line 434 fn c195_l434_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c195_l434_action_invoke"); - let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((0.00000000000000000000000072854914f32)), Value::F32((0.0000000000000000000042365796f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000042366535f32))))); + let result = instance.call( + "f32.no_fold_to_hypot", + &[ + Value::F32((0.00000000000000000000000072854914f32)), + Value::F32((0.0000000000000000000042365796f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.0000000000000000000042366535f32)))) + ); result.map(|_| ()) } // Line 435 fn c196_l435_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c196_l435_action_invoke"); - let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((-0.0000000000000000000007470285f32)), Value::F32((-0.000000000000000000000000000000007453745f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000007468044f32))))); + let result = instance.call( + "f32.no_fold_to_hypot", + &[ + Value::F32((-0.0000000000000000000007470285f32)), + Value::F32((-0.000000000000000000000000000000007453745f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.0000000000000000000007468044f32)))) + ); result.map(|_| ()) } // Line 436 fn c197_l436_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c197_l436_action_invoke"); - let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((-0.0000000000000000000000000000000000770895f32)), Value::F32((-0.0000000000000000000032627214f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000032627695f32))))); + let result = instance.call( + "f32.no_fold_to_hypot", + &[ + Value::F32((-0.0000000000000000000000000000000000770895f32)), + Value::F32((-0.0000000000000000000032627214f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.0000000000000000000032627695f32)))) + ); result.map(|_| ()) } // Line 437 fn c198_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c198_l437_action_invoke"); - let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((-35.42818f32)), Value::F32((174209.48f32))]); + let result = instance.call( + "f32.no_fold_to_hypot", + &[Value::F32((-35.42818f32)), Value::F32((174209.48f32))], + ); assert_eq!(result, Ok(Some(Value::F32((174209.5f32))))); result.map(|_| ()) } @@ -2633,8 +3563,17 @@ fn c198_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 438 fn c199_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c199_l438_action_invoke"); - let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((0.000000000000000000000020628143f32)), Value::F32((-0.00000000000000000000046344753f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000463032f32))))); + let result = instance.call( + "f32.no_fold_to_hypot", + &[ + Value::F32((0.000000000000000000000020628143f32)), + Value::F32((-0.00000000000000000000046344753f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.000000000000000000000463032f32)))) + ); result.map(|_| ()) } @@ -2706,8 +3645,11 @@ fn create_module_27() -> Box { (export \"f32.no_approximate_reciprocal\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_27(instance: &mut Instance) { @@ -2718,7 +3660,10 @@ fn start_module_27(instance: &mut Instance) { // Line 452 fn c206_l452_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c206_l452_action_invoke"); - let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((-0.0011329757f32))]); + let result = instance.call( + "f32.no_approximate_reciprocal", + &[Value::F32((-0.0011329757f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-882.6315f32))))); result.map(|_| ()) } @@ -2726,32 +3671,58 @@ fn c206_l452_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 453 fn c207_l453_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c207_l453_action_invoke"); - let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((323753010000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000003088774f32))))); + let result = instance.call( + "f32.no_approximate_reciprocal", + &[Value::F32((323753010000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000003088774f32) + ))) + ); result.map(|_| ()) } // Line 454 fn c208_l454_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c208_l454_action_invoke"); - let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((-0.0000000000000000000000000001272599f32))]); - assert_eq!(result, Ok(Some(Value::F32((-7857934600000000000000000000.0f32))))); + let result = instance.call( + "f32.no_approximate_reciprocal", + &[Value::F32((-0.0000000000000000000000000001272599f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-7857934600000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 455 fn c209_l455_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c209_l455_action_invoke"); - let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((103020680000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000009706789f32))))); + let result = instance.call( + "f32.no_approximate_reciprocal", + &[Value::F32((103020680000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.000000000000000000000009706789f32)))) + ); result.map(|_| ()) } // Line 456 fn c210_l456_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c210_l456_action_invoke"); - let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((-0.00000000000000000000000028443763f32))]); - assert_eq!(result, Ok(Some(Value::F32((-3515709300000000000000000.0f32))))); + let result = instance.call( + "f32.no_approximate_reciprocal", + &[Value::F32((-0.00000000000000000000000028443763f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-3515709300000000000000000.0f32)))) + ); result.map(|_| ()) } @@ -2786,8 +3757,11 @@ fn create_module_28() -> Box { (export \"f64.no_fuse_reciprocal_sqrt\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_28(instance: &mut Instance) { @@ -2798,7 +3772,10 @@ fn start_module_28(instance: &mut Instance) { // Line 467 fn c212_l467_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c212_l467_action_invoke"); - let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.00000000000016117865f32))]); + let result = instance.call( + "f32.no_approximate_reciprocal_sqrt", + &[Value::F32((0.00000000000016117865f32))], + ); assert_eq!(result, Ok(Some(Value::F32((2490842.5f32))))); result.map(|_| ()) } @@ -2806,7 +3783,10 @@ fn c212_l467_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 468 fn c213_l468_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c213_l468_action_invoke"); - let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.0074491366f32))]); + let result = instance.call( + "f32.no_approximate_reciprocal_sqrt", + &[Value::F32((0.0074491366f32))], + ); assert_eq!(result, Ok(Some(Value::F32((11.58636f32))))); result.map(|_| ()) } @@ -2814,7 +3794,10 @@ fn c213_l468_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 469 fn c214_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c214_l469_action_invoke"); - let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.00000000000000000002339817f32))]); + let result = instance.call( + "f32.no_approximate_reciprocal_sqrt", + &[Value::F32((0.00000000000000000002339817f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6537460000.0f32))))); result.map(|_| ()) } @@ -2822,7 +3805,10 @@ fn c214_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 470 fn c215_l470_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c215_l470_action_invoke"); - let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.00000000000011123504f32))]); + let result = instance.call( + "f32.no_approximate_reciprocal_sqrt", + &[Value::F32((0.00000000000011123504f32))], + ); assert_eq!(result, Ok(Some(Value::F32((2998328.3f32))))); result.map(|_| ()) } @@ -2830,7 +3816,10 @@ fn c215_l470_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 471 fn c216_l471_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c216_l471_action_invoke"); - let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.000000000000000000000000017653063f32))]); + let result = instance.call( + "f32.no_approximate_reciprocal_sqrt", + &[Value::F32((0.000000000000000000000000017653063f32))], + ); assert_eq!(result, Ok(Some(Value::F32((7526446300000.0f32))))); result.map(|_| ()) } @@ -2847,15 +3836,26 @@ fn c217_l473_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c218_l474_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c218_l474_action_invoke"); let result = instance.call("f64.no_fuse_reciprocal_sqrt", &[Value::F64((4752392260007119000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000014505872638954843f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.000000000000000000000000000000000000000000000014505872638954843f64) + ))) + ); result.map(|_| ()) } // Line 475 fn c219_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c219_l475_action_invoke"); - let result = instance.call("f64.no_fuse_reciprocal_sqrt", &[Value::F64((29014415885392436000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.00000000000000018564920084793608f64))))); + let result = instance.call( + "f64.no_fuse_reciprocal_sqrt", + &[Value::F64((29014415885392436000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F64((0.00000000000000018564920084793608f64)))) + ); result.map(|_| ()) } @@ -2870,8 +3870,18 @@ fn c220_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 477 fn c221_l477_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c221_l477_action_invoke"); - let result = instance.call("f64.no_fuse_reciprocal_sqrt", &[Value::F64((151596415440704430000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000008121860649480894f64))))); + let result = instance.call( + "f64.no_fuse_reciprocal_sqrt", + &[Value::F64( + (151596415440704430000000000000000000000000000.0f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.00000000000000000000008121860649480894f64) + ))) + ); result.map(|_| ()) } @@ -2904,8 +3914,11 @@ fn create_module_29() -> Box { (export \"f32.no_approximate_sqrt_reciprocal\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_29(instance: &mut Instance) { @@ -2916,7 +3929,10 @@ fn start_module_29(instance: &mut Instance) { // Line 486 fn c223_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c223_l486_action_invoke"); - let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((1895057100000000000.0f32))]); + let result = instance.call( + "f32.no_approximate_sqrt_reciprocal", + &[Value::F32((1895057100000000000.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000000072642176f32))))); result.map(|_| ()) } @@ -2924,7 +3940,10 @@ fn c223_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 487 fn c224_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c224_l487_action_invoke"); - let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((0.002565894f32))]); + let result = instance.call( + "f32.no_approximate_sqrt_reciprocal", + &[Value::F32((0.002565894f32))], + ); assert_eq!(result, Ok(Some(Value::F32((19.741522f32))))); result.map(|_| ()) } @@ -2932,7 +3951,10 @@ fn c224_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 488 fn c225_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c225_l488_action_invoke"); - let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((632654500000000000000.0f32))]); + let result = instance.call( + "f32.no_approximate_sqrt_reciprocal", + &[Value::F32((632654500000000000000.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.000000000039757284f32))))); result.map(|_| ()) } @@ -2940,7 +3962,10 @@ fn c225_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 489 fn c226_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c226_l489_action_invoke"); - let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((14153.539f32))]); + let result = instance.call( + "f32.no_approximate_sqrt_reciprocal", + &[Value::F32((14153.539f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.008405576f32))))); result.map(|_| ()) } @@ -2948,7 +3973,10 @@ fn c226_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 490 fn c227_l490_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c227_l490_action_invoke"); - let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((26173730000000000000000000000000.0f32))]); + let result = instance.call( + "f32.no_approximate_sqrt_reciprocal", + &[Value::F32((26173730000000000000000000000000.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000000000000019546418f32))))); result.map(|_| ()) } @@ -2992,8 +4020,11 @@ fn create_module_30() -> Box { (export \"i64.no_fold_f64_u\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_30(instance: &mut Instance) { @@ -3068,7 +4099,10 @@ fn c236_l514_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 515 fn c237_l515_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c237_l515_action_invoke"); - let result = instance.call("i64.no_fold_f64_s", &[Value::I64(-1152921504606845952 as i64)]); + let result = instance.call( + "i64.no_fold_f64_s", + &[Value::I64(-1152921504606845952 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(-1152921504606845952 as i64)))); result.map(|_| ()) } @@ -3092,7 +4126,10 @@ fn c239_l518_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 519 fn c240_l519_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c240_l519_action_invoke"); - let result = instance.call("i64.no_fold_f64_u", &[Value::I64(-1152921504606845952 as i64)]); + let result = instance.call( + "i64.no_fold_f64_u", + &[Value::I64(-1152921504606845952 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(-1152921504606846976 as i64)))); result.map(|_| ()) } @@ -3137,8 +4174,11 @@ fn create_module_31() -> Box { (export \"f64.no_fold_add_sub\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_31(instance: &mut Instance) { @@ -3149,7 +4189,13 @@ fn start_module_31(instance: &mut Instance) { // Line 530 fn c242_l530_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c242_l530_action_invoke"); - let result = instance.call("f32.no_fold_add_sub", &[Value::F32((0.000000000000012138282f32)), Value::F32((-0.000000020946384f32))]); + let result = instance.call( + "f32.no_fold_add_sub", + &[ + Value::F32((0.000000000000012138282f32)), + Value::F32((-0.000000020946384f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.000000000000012434498f32))))); result.map(|_| ()) } @@ -3157,7 +4203,13 @@ fn c242_l530_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 531 fn c243_l531_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c243_l531_action_invoke"); - let result = instance.call("f32.no_fold_add_sub", &[Value::F32((-0.00000019768197f32)), Value::F32((0.0000037154566f32))]); + let result = instance.call( + "f32.no_fold_add_sub", + &[ + Value::F32((-0.00000019768197f32)), + Value::F32((0.0000037154566f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.00000019768208f32))))); result.map(|_| ()) } @@ -3165,24 +4217,53 @@ fn c243_l531_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 532 fn c244_l532_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c244_l532_action_invoke"); - let result = instance.call("f32.no_fold_add_sub", &[Value::F32((-9596213000000000000000000.0f32)), Value::F32((-3538041400000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-9671407000000000000000000.0f32))))); + let result = instance.call( + "f32.no_fold_add_sub", + &[ + Value::F32((-9596213000000000000000000.0f32)), + Value::F32((-3538041400000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-9671407000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 533 fn c245_l533_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c245_l533_action_invoke"); - let result = instance.call("f32.no_fold_add_sub", &[Value::F32((0.000000000000000000000005054346f32)), Value::F32((0.000000000000000024572656f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000049630837f32))))); + let result = instance.call( + "f32.no_fold_add_sub", + &[ + Value::F32((0.000000000000000000000005054346f32)), + Value::F32((0.000000000000000024572656f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.0000000000000000000000049630837f32)))) + ); result.map(|_| ()) } // Line 534 fn c246_l534_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c246_l534_action_invoke"); - let result = instance.call("f32.no_fold_add_sub", &[Value::F32((-0.0000000000000000000000000000000033693147f32)), Value::F32((-0.000000000000000000000000071014917f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000006162976f32))))); + let result = instance.call( + "f32.no_fold_add_sub", + &[ + Value::F32((-0.0000000000000000000000000000000033693147f32)), + Value::F32((-0.000000000000000000000000071014917f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000006162976f32) + ))) + ); result.map(|_| ()) } @@ -3205,8 +4286,17 @@ fn c248_l537_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 538 fn c249_l538_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c249_l538_action_invoke"); - let result = instance.call("f64.no_fold_add_sub", &[Value::F64((-0.0000000013604511322066714f64)), Value::F64((-0.1751431740707098f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000013604511406306585f64))))); + let result = instance.call( + "f64.no_fold_add_sub", + &[ + Value::F64((-0.0000000013604511322066714f64)), + Value::F64((-0.1751431740707098f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64((-0.0000000013604511406306585f64)))) + ); result.map(|_| ()) } @@ -3264,8 +4354,11 @@ fn create_module_32() -> Box { (export \"f64.no_fold_sub_add\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_32(instance: &mut Instance) { @@ -3276,7 +4369,10 @@ fn start_module_32(instance: &mut Instance) { // Line 551 fn c253_l551_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c253_l551_action_invoke"); - let result = instance.call("f32.no_fold_sub_add", &[Value::F32((-676.47437f32)), Value::F32((403.0368f32))]); + let result = instance.call( + "f32.no_fold_sub_add", + &[Value::F32((-676.47437f32)), Value::F32((403.0368f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-676.4744f32))))); result.map(|_| ()) } @@ -3284,15 +4380,29 @@ fn c253_l551_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 552 fn c254_l552_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c254_l552_action_invoke"); - let result = instance.call("f32.no_fold_sub_add", &[Value::F32((-0.0000000000000000000000000000000006305943f32)), Value::F32((0.0000000000000000000000000000367186f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000063194576f32))))); + let result = instance.call( + "f32.no_fold_sub_add", + &[ + Value::F32((-0.0000000000000000000000000000000006305943f32)), + Value::F32((0.0000000000000000000000000000367186f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.00000000000000000000000000000000063194576f32) + ))) + ); result.map(|_| ()) } // Line 553 fn c255_l553_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c255_l553_action_invoke"); - let result = instance.call("f32.no_fold_sub_add", &[Value::F32((83184800.0f32)), Value::F32((46216217000.0f32))]); + let result = instance.call( + "f32.no_fold_sub_add", + &[Value::F32((83184800.0f32)), Value::F32((46216217000.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((83185660.0f32))))); result.map(|_| ()) } @@ -3300,7 +4410,13 @@ fn c255_l553_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 554 fn c256_l554_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c256_l554_action_invoke"); - let result = instance.call("f32.no_fold_sub_add", &[Value::F32((0.000000000002211957f32)), Value::F32((-0.00000001043793f32))]); + let result = instance.call( + "f32.no_fold_sub_add", + &[ + Value::F32((0.000000000002211957f32)), + Value::F32((-0.00000001043793f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0000000000022115643f32))))); result.map(|_| ()) } @@ -3308,7 +4424,10 @@ fn c256_l554_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 555 fn c257_l555_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c257_l555_action_invoke"); - let result = instance.call("f32.no_fold_sub_add", &[Value::F32((0.14944395f32)), Value::F32((-27393.65f32))]); + let result = instance.call( + "f32.no_fold_sub_add", + &[Value::F32((0.14944395f32)), Value::F32((-27393.65f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.15039063f32))))); result.map(|_| ()) } @@ -3317,7 +4436,12 @@ fn c257_l555_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c258_l557_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c258_l557_action_invoke"); let result = instance.call("f64.no_fold_sub_add", &[Value::F64((90365982617946240000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((-958186427535552000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((90365982617946280000000000000000000000000000000000000000000000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (90365982617946280000000000000000000000000000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -3333,14 +4457,25 @@ fn c259_l558_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c260_l559_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c260_l559_action_invoke"); let result = instance.call("f64.no_fold_sub_add", &[Value::F64((4095348452776429000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((-4050190019576568700000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((4070815637249397500000000000000000000000000000000000000000000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (4070815637249397500000000000000000000000000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } // Line 560 fn c261_l560_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c261_l560_action_invoke"); - let result = instance.call("f64.no_fold_sub_add", &[Value::F64((0.000000024008889207554433f64)), Value::F64((-0.00017253797929188484f64))]); + let result = instance.call( + "f64.no_fold_sub_add", + &[ + Value::F64((0.000000024008889207554433f64)), + Value::F64((-0.00017253797929188484f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.00000002400888920756506f64))))); result.map(|_| ()) } @@ -3391,8 +4526,11 @@ fn create_module_33() -> Box { (export \"f64.no_fold_mul_div\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_33(instance: &mut Instance) { @@ -3403,7 +4541,13 @@ fn start_module_33(instance: &mut Instance) { // Line 572 fn c264_l572_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c264_l572_action_invoke"); - let result = instance.call("f32.no_fold_mul_div", &[Value::F32((-32476715000000000.0f32)), Value::F32((0.000000000000010121375f32))]); + let result = instance.call( + "f32.no_fold_mul_div", + &[ + Value::F32((-32476715000000000.0f32)), + Value::F32((0.000000000000010121375f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-32476713000000000.0f32))))); result.map(|_| ()) } @@ -3411,7 +4555,13 @@ fn c264_l572_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 573 fn c265_l573_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c265_l573_action_invoke"); - let result = instance.call("f32.no_fold_mul_div", &[Value::F32((-0.000000015561163f32)), Value::F32((0.000000000000000000000000000000015799828f32))]); + let result = instance.call( + "f32.no_fold_mul_div", + &[ + Value::F32((-0.000000015561163f32)), + Value::F32((0.000000000000000000000000000000015799828f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.000000015561145f32))))); result.map(|_| ()) } @@ -3419,7 +4569,13 @@ fn c265_l573_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 574 fn c266_l574_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c266_l574_action_invoke"); - let result = instance.call("f32.no_fold_mul_div", &[Value::F32((-0.00000000000000676311f32)), Value::F32((-441324000000000.0f32))]); + let result = instance.call( + "f32.no_fold_mul_div", + &[ + Value::F32((-0.00000000000000676311f32)), + Value::F32((-441324000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000067631096f32))))); result.map(|_| ()) } @@ -3427,7 +4583,13 @@ fn c266_l574_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 575 fn c267_l575_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c267_l575_action_invoke"); - let result = instance.call("f32.no_fold_mul_div", &[Value::F32((7505613700000000.0f32)), Value::F32((-2160384100000000000.0f32))]); + let result = instance.call( + "f32.no_fold_mul_div", + &[ + Value::F32((7505613700000000.0f32)), + Value::F32((-2160384100000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((7505613000000000.0f32))))); result.map(|_| ()) } @@ -3435,8 +4597,19 @@ fn c267_l575_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 576 fn c268_l576_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c268_l576_action_invoke"); - let result = instance.call("f32.no_fold_mul_div", &[Value::F32((-0.0000000000000000000000000002362576f32)), Value::F32((-0.000000000010808759f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000023625765f32))))); + let result = instance.call( + "f32.no_fold_mul_div", + &[ + Value::F32((-0.0000000000000000000000000002362576f32)), + Value::F32((-0.000000000010808759f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.00000000000000000000000000023625765f32) + ))) + ); result.map(|_| ()) } @@ -3460,7 +4633,12 @@ fn c270_l579_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c271_l580_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c271_l580_action_invoke"); let result = instance.call("f64.no_fold_mul_div", &[Value::F64((-718011781190294800000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009320036042623636f64))]); - assert_eq!(result, Ok(Some(Value::F64((-718011781190294750000000000000000000000000000000000000000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (-718011781190294750000000000000000000000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -3468,7 +4646,12 @@ fn c271_l580_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c272_l581_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c272_l581_action_invoke"); let result = instance.call("f64.no_fold_mul_div", &[Value::F64((0.000000000000000000000000000000000000000000000000017260010724693063f64)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003568792428129926f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000001661286799244216f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.00000000000000000000000000000000000000000000000001661286799244216f64) + ))) + ); result.map(|_| ()) } @@ -3518,8 +4701,11 @@ fn create_module_34() -> Box { (export \"f64.no_fold_div_mul\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_34(instance: &mut Instance) { @@ -3530,7 +4716,13 @@ fn start_module_34(instance: &mut Instance) { // Line 593 fn c275_l593_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c275_l593_action_invoke"); - let result = instance.call("f32.no_fold_div_mul", &[Value::F32((-511517980000.0f32)), Value::F32((986062200.0f32))]); + let result = instance.call( + "f32.no_fold_div_mul", + &[ + Value::F32((-511517980000.0f32)), + Value::F32((986062200.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-511517950000.0f32))))); result.map(|_| ()) } @@ -3538,32 +4730,72 @@ fn c275_l593_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 594 fn c276_l594_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c276_l594_action_invoke"); - let result = instance.call("f32.no_fold_div_mul", &[Value::F32((-0.00000000000000024944853f32)), Value::F32((-0.0000041539834f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000024944856f32))))); + let result = instance.call( + "f32.no_fold_div_mul", + &[ + Value::F32((-0.00000000000000024944853f32)), + Value::F32((-0.0000041539834f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-0.00000000000000024944856f32)))) + ); result.map(|_| ()) } // Line 595 fn c277_l595_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c277_l595_action_invoke"); - let result = instance.call("f32.no_fold_div_mul", &[Value::F32((0.000000000000000000000000000000000000020827855f32)), Value::F32((-235.19847f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000020828013f32))))); + let result = instance.call( + "f32.no_fold_div_mul", + &[ + Value::F32((0.000000000000000000000000000000000000020827855f32)), + Value::F32((-235.19847f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000020828013f32) + ))) + ); result.map(|_| ()) } // Line 596 fn c278_l596_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c278_l596_action_invoke"); - let result = instance.call("f32.no_fold_div_mul", &[Value::F32((-0.000000000000000000000062499487f32)), Value::F32((-696312600000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000006249919f32))))); + let result = instance.call( + "f32.no_fold_div_mul", + &[ + Value::F32((-0.000000000000000000000062499487f32)), + Value::F32((-696312600000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-0.00000000000000000000006249919f32)))) + ); result.map(|_| ()) } // Line 597 fn c279_l597_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c279_l597_action_invoke"); - let result = instance.call("f32.no_fold_div_mul", &[Value::F32((0.0000000000000000000000000000058353514f32)), Value::F32((212781120.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000005835352f32))))); + let result = instance.call( + "f32.no_fold_div_mul", + &[ + Value::F32((0.0000000000000000000000000000058353514f32)), + Value::F32((212781120.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000005835352f32) + ))) + ); result.map(|_| ()) } @@ -3587,7 +4819,12 @@ fn c281_l600_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c282_l601_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c282_l601_action_invoke"); let result = instance.call("f64.no_fold_div_mul", &[Value::F64((-0.00000000000000000000000000000000000000000003140341989542684f64)), Value::F64((942829809081919600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000031403419895426836f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.000000000000000000000000000000000000000000031403419895426836f64) + ))) + ); result.map(|_| ()) } @@ -3645,8 +4882,11 @@ fn create_module_35() -> Box { (export \"f64.no_fold_div2_mul2\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_35(instance: &mut Instance) { @@ -3657,8 +4897,18 @@ fn start_module_35(instance: &mut Instance) { // Line 614 fn c286_l614_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c286_l614_action_invoke"); - let result = instance.call("f32.no_fold_div2_mul2", &[Value::F32((0.000000000000000000000000000000000000023509886f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32))))); + let result = instance.call( + "f32.no_fold_div2_mul2", + &[Value::F32( + (0.000000000000000000000000000000000000023509886f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000023509887f32) + ))) + ); result.map(|_| ()) } @@ -3690,8 +4940,11 @@ fn create_module_36() -> Box { (export \"no_fold_demote_promote\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_36(instance: &mut Instance) { @@ -3702,40 +4955,82 @@ fn start_module_36(instance: &mut Instance) { // Line 624 fn c289_l624_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c289_l624_action_invoke"); - let result = instance.call("no_fold_demote_promote", &[Value::F64((-0.00000000000000000000000000000000000000017176297220569481f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000017176275796615013f64))))); + let result = instance.call( + "no_fold_demote_promote", + &[Value::F64( + (-0.00000000000000000000000000000000000000017176297220569481f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.00000000000000000000000000000000000000017176275796615013f64) + ))) + ); result.map(|_| ()) } // Line 625 fn c290_l625_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c290_l625_action_invoke"); - let result = instance.call("no_fold_demote_promote", &[Value::F64((-0.000000000000000000000000028464775573304055f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000002846477619188087f64))))); + let result = instance.call( + "no_fold_demote_promote", + &[Value::F64( + (-0.000000000000000000000000028464775573304055f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.00000000000000000000000002846477619188087f64) + ))) + ); result.map(|_| ()) } // Line 626 fn c291_l626_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c291_l626_action_invoke"); - let result = instance.call("no_fold_demote_promote", &[Value::F64((208970699699909230000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((208970700445326000000000000000000.0f64))))); + let result = instance.call( + "no_fold_demote_promote", + &[Value::F64((208970699699909230000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F64((208970700445326000000000000000000.0f64)))) + ); result.map(|_| ()) } // Line 627 fn c292_l627_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c292_l627_action_invoke"); - let result = instance.call("no_fold_demote_promote", &[Value::F64((-0.0000000000000000000000000047074160416121775f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000047074161331556024f64))))); + let result = instance.call( + "no_fold_demote_promote", + &[Value::F64( + (-0.0000000000000000000000000047074160416121775f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.0000000000000000000000000047074161331556024f64) + ))) + ); result.map(|_| ()) } // Line 628 fn c293_l628_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c293_l628_action_invoke"); - let result = instance.call("no_fold_demote_promote", &[Value::F64((23359451497950880000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((23359452224542198000000000000000.0f64))))); + let result = instance.call( + "no_fold_demote_promote", + &[Value::F64((23359451497950880000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F64((23359452224542198000000000000000.0f64)))) + ); result.map(|_| ()) } @@ -3762,8 +5057,11 @@ fn create_module_37() -> Box { (export \"no_fold_promote_demote\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_37(instance: &mut Instance) { @@ -3773,12 +5071,21 @@ fn start_module_37(instance: &mut Instance) { // Line 638 fn c295_l638_assert_return_arithmetic_nan(instance: &mut Instance) { - println!("Executing function {}", "c295_l638_assert_return_arithmetic_nan"); - let result = instance.call("no_fold_promote_demote", &[Value::F32(f32::from_bits(2141192192))]).unwrap().expect("Missing result in c295_l638_assert_return_arithmetic_nan"); + println!( + "Executing function {}", + "c295_l638_assert_return_arithmetic_nan" + ); + let result = instance + .call( + "no_fold_promote_demote", + &[Value::F32(f32::from_bits(2141192192))], + ) + .unwrap() + .expect("Missing result in c295_l638_assert_return_arithmetic_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -3801,64 +5108,140 @@ fn c297_l640_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 641 fn c298_l641_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c298_l641_action_invoke"); - let result = instance.call("no_fold_promote_demote", &[Value::F32((0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "no_fold_promote_demote", + &[Value::F32( + (0.000000000000000000000000000000000000000000001f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 642 fn c299_l642_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c299_l642_action_invoke"); - let result = instance.call("no_fold_promote_demote", &[Value::F32((-0.000000000000000000000000000000000000000000001f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "no_fold_promote_demote", + &[Value::F32( + (-0.000000000000000000000000000000000000000000001f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } // Line 643 fn c300_l643_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c300_l643_action_invoke"); - let result = instance.call("no_fold_promote_demote", &[Value::F32((0.000000000000000000000000000000000000011754942f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32))))); + let result = instance.call( + "no_fold_promote_demote", + &[Value::F32( + (0.000000000000000000000000000000000000011754942f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754942f32) + ))) + ); result.map(|_| ()) } // Line 644 fn c301_l644_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c301_l644_action_invoke"); - let result = instance.call("no_fold_promote_demote", &[Value::F32((-0.000000000000000000000000000000000000011754942f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32))))); + let result = instance.call( + "no_fold_promote_demote", + &[Value::F32( + (-0.000000000000000000000000000000000000011754942f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754942f32) + ))) + ); result.map(|_| ()) } // Line 645 fn c302_l645_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c302_l645_action_invoke"); - let result = instance.call("no_fold_promote_demote", &[Value::F32((0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "no_fold_promote_demote", + &[Value::F32( + (0.000000000000000000000000000000000000011754944f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 646 fn c303_l646_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c303_l646_action_invoke"); - let result = instance.call("no_fold_promote_demote", &[Value::F32((-0.000000000000000000000000000000000000011754944f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "no_fold_promote_demote", + &[Value::F32( + (-0.000000000000000000000000000000000000011754944f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } // Line 647 fn c304_l647_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c304_l647_action_invoke"); - let result = instance.call("no_fold_promote_demote", &[Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "no_fold_promote_demote", + &[Value::F32((340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 648 fn c305_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c305_l648_action_invoke"); - let result = instance.call("no_fold_promote_demote", &[Value::F32((-340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "no_fold_promote_demote", + &[Value::F32((-340282350000000000000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -3919,8 +5302,11 @@ fn create_module_38() -> Box { (export \"no_demote_mixed_add_commuted\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_38(instance: &mut Instance) { @@ -3931,15 +5317,32 @@ fn start_module_38(instance: &mut Instance) { // Line 661 fn c309_l661_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c309_l661_action_invoke"); - let result = instance.call("no_demote_mixed_add", &[Value::F64((0.00000000000000000000000000004941266527909197f64)), Value::F32((0.0000000000000000000000000000000000018767183f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000049412667f32))))); + let result = instance.call( + "no_demote_mixed_add", + &[ + Value::F64((0.00000000000000000000000000004941266527909197f64)), + Value::F32((0.0000000000000000000000000000000000018767183f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000049412667f32) + ))) + ); result.map(|_| ()) } // Line 662 fn c310_l662_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c310_l662_action_invoke"); - let result = instance.call("no_demote_mixed_add", &[Value::F64((140851523637.69385f64)), Value::F32((401096440000.0f32))]); + let result = instance.call( + "no_demote_mixed_add", + &[ + Value::F64((140851523637.69385f64)), + Value::F32((401096440000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((541947950000.0f32))))); result.map(|_| ()) } @@ -3947,15 +5350,32 @@ fn c310_l662_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 663 fn c311_l663_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c311_l663_action_invoke"); - let result = instance.call("no_demote_mixed_add", &[Value::F64((0.0000000000000000000000000000000000020831160914192852f64)), Value::F32((-0.0000000000000000000000000000000000006050095f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000014781066f32))))); + let result = instance.call( + "no_demote_mixed_add", + &[ + Value::F64((0.0000000000000000000000000000000000020831160914192852f64)), + Value::F32((-0.0000000000000000000000000000000000006050095f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.0000000000000000000000000000000000014781066f32) + ))) + ); result.map(|_| ()) } // Line 664 fn c312_l664_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c312_l664_action_invoke"); - let result = instance.call("no_demote_mixed_add", &[Value::F64((-0.0000010032827553674626f64)), Value::F32((0.0000000019312918f32))]); + let result = instance.call( + "no_demote_mixed_add", + &[ + Value::F64((-0.0000010032827553674626f64)), + Value::F32((0.0000000019312918f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0000010013515f32))))); result.map(|_| ()) } @@ -3963,7 +5383,13 @@ fn c312_l664_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 665 fn c313_l665_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c313_l665_action_invoke"); - let result = instance.call("no_demote_mixed_add", &[Value::F64((-0.0000013840207035752711f64)), Value::F32((-0.0000000000005202814f32))]); + let result = instance.call( + "no_demote_mixed_add", + &[ + Value::F64((-0.0000013840207035752711f64)), + Value::F32((-0.0000000000005202814f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0000013840212f32))))); result.map(|_| ()) } @@ -3971,15 +5397,32 @@ fn c313_l665_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 667 fn c314_l667_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c314_l667_action_invoke"); - let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((0.0000000000000000000000000000000000018767183f32)), Value::F64((0.00000000000000000000000000004941266527909197f64))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000049412667f32))))); + let result = instance.call( + "no_demote_mixed_add_commuted", + &[ + Value::F32((0.0000000000000000000000000000000000018767183f32)), + Value::F64((0.00000000000000000000000000004941266527909197f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000049412667f32) + ))) + ); result.map(|_| ()) } // Line 668 fn c315_l668_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c315_l668_action_invoke"); - let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((401096440000.0f32)), Value::F64((140851523637.69385f64))]); + let result = instance.call( + "no_demote_mixed_add_commuted", + &[ + Value::F32((401096440000.0f32)), + Value::F64((140851523637.69385f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((541947950000.0f32))))); result.map(|_| ()) } @@ -3987,15 +5430,32 @@ fn c315_l668_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 669 fn c316_l669_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c316_l669_action_invoke"); - let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((-0.0000000000000000000000000000000000006050095f32)), Value::F64((0.0000000000000000000000000000000000020831160914192852f64))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000014781066f32))))); + let result = instance.call( + "no_demote_mixed_add_commuted", + &[ + Value::F32((-0.0000000000000000000000000000000000006050095f32)), + Value::F64((0.0000000000000000000000000000000000020831160914192852f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.0000000000000000000000000000000000014781066f32) + ))) + ); result.map(|_| ()) } // Line 670 fn c317_l670_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c317_l670_action_invoke"); - let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((0.0000000019312918f32)), Value::F64((-0.0000010032827553674626f64))]); + let result = instance.call( + "no_demote_mixed_add_commuted", + &[ + Value::F32((0.0000000019312918f32)), + Value::F64((-0.0000010032827553674626f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0000010013515f32))))); result.map(|_| ()) } @@ -4003,7 +5463,13 @@ fn c317_l670_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 671 fn c318_l671_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c318_l671_action_invoke"); - let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((-0.0000000000005202814f32)), Value::F64((-0.0000013840207035752711f64))]); + let result = instance.call( + "no_demote_mixed_add_commuted", + &[ + Value::F32((-0.0000000000005202814f32)), + Value::F64((-0.0000013840207035752711f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0000013840212f32))))); result.map(|_| ()) } @@ -4038,8 +5504,11 @@ fn create_module_39() -> Box { (export \"no_demote_mixed_sub\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_39(instance: &mut Instance) { @@ -4050,15 +5519,30 @@ fn start_module_39(instance: &mut Instance) { // Line 680 fn c320_l680_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c320_l680_action_invoke"); - let result = instance.call("no_demote_mixed_sub", &[Value::F64((7869935327202668000000000.0f64)), Value::F32((4086347000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((7869931000000000000000000.0f32))))); + let result = instance.call( + "no_demote_mixed_sub", + &[ + Value::F64((7869935327202668000000000.0f64)), + Value::F32((4086347000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((7869931000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 681 fn c321_l681_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c321_l681_action_invoke"); - let result = instance.call("no_demote_mixed_sub", &[Value::F64((-1535841968.9056544f64)), Value::F32((239897.28f32))]); + let result = instance.call( + "no_demote_mixed_sub", + &[ + Value::F64((-1535841968.9056544f64)), + Value::F32((239897.28f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1536081900.0f32))))); result.map(|_| ()) } @@ -4066,7 +5550,13 @@ fn c321_l681_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 682 fn c322_l682_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c322_l682_action_invoke"); - let result = instance.call("no_demote_mixed_sub", &[Value::F64((-102.19459272722602f64)), Value::F32((0.00039426138f32))]); + let result = instance.call( + "no_demote_mixed_sub", + &[ + Value::F64((-102.19459272722602f64)), + Value::F32((0.00039426138f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-102.194984f32))))); result.map(|_| ()) } @@ -4074,7 +5564,13 @@ fn c322_l682_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 683 fn c323_l683_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c323_l683_action_invoke"); - let result = instance.call("no_demote_mixed_sub", &[Value::F64((0.00000000000000005645470375565188f64)), Value::F32((0.0000000000000000000005851077f32))]); + let result = instance.call( + "no_demote_mixed_sub", + &[ + Value::F64((0.00000000000000005645470375565188f64)), + Value::F32((0.0000000000000000000005851077f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000000000000005645412f32))))); result.map(|_| ()) } @@ -4082,7 +5578,13 @@ fn c323_l683_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 684 fn c324_l684_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c324_l684_action_invoke"); - let result = instance.call("no_demote_mixed_sub", &[Value::F64((27090.388466832894f64)), Value::F32((63120.89f32))]); + let result = instance.call( + "no_demote_mixed_sub", + &[ + Value::F64((27090.388466832894f64)), + Value::F32((63120.89f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-36030.504f32))))); result.map(|_| ()) } @@ -4186,8 +5688,11 @@ fn create_module_40() -> Box { (export \"f64.i64.no_fold_trunc_u_convert_u\" (func 15))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_40(instance: &mut Instance) { @@ -4206,7 +5711,10 @@ fn c326_l723_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 724 fn c327_l724_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c327_l724_action_invoke"); - let result = instance.call("f32.i32.no_fold_trunc_s_convert_s", &[Value::F32((-1.5f32))]); + let result = instance.call( + "f32.i32.no_fold_trunc_s_convert_s", + &[Value::F32((-1.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -4222,7 +5730,10 @@ fn c328_l725_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 726 fn c329_l726_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c329_l726_action_invoke"); - let result = instance.call("f32.i32.no_fold_trunc_u_convert_s", &[Value::F32((-0.5f32))]); + let result = instance.call( + "f32.i32.no_fold_trunc_u_convert_s", + &[Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -4238,7 +5749,10 @@ fn c330_l727_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 728 fn c331_l728_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c331_l728_action_invoke"); - let result = instance.call("f32.i32.no_fold_trunc_s_convert_u", &[Value::F32((-1.5f32))]); + let result = instance.call( + "f32.i32.no_fold_trunc_s_convert_u", + &[Value::F32((-1.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((4294967300.0f32))))); result.map(|_| ()) } @@ -4254,7 +5768,10 @@ fn c332_l729_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 730 fn c333_l730_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c333_l730_action_invoke"); - let result = instance.call("f32.i32.no_fold_trunc_u_convert_u", &[Value::F32((-0.5f32))]); + let result = instance.call( + "f32.i32.no_fold_trunc_u_convert_u", + &[Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -4270,7 +5787,10 @@ fn c334_l732_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 733 fn c335_l733_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c335_l733_action_invoke"); - let result = instance.call("f64.i32.no_fold_trunc_s_convert_s", &[Value::F64((-1.5f64))]); + let result = instance.call( + "f64.i32.no_fold_trunc_s_convert_s", + &[Value::F64((-1.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -4286,7 +5806,10 @@ fn c336_l734_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 735 fn c337_l735_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c337_l735_action_invoke"); - let result = instance.call("f64.i32.no_fold_trunc_u_convert_s", &[Value::F64((-0.5f64))]); + let result = instance.call( + "f64.i32.no_fold_trunc_u_convert_s", + &[Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -4302,7 +5825,10 @@ fn c338_l736_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 737 fn c339_l737_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c339_l737_action_invoke"); - let result = instance.call("f64.i32.no_fold_trunc_s_convert_u", &[Value::F64((-1.5f64))]); + let result = instance.call( + "f64.i32.no_fold_trunc_s_convert_u", + &[Value::F64((-1.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((4294967295.0f64))))); result.map(|_| ()) } @@ -4318,7 +5844,10 @@ fn c340_l738_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 739 fn c341_l739_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c341_l739_action_invoke"); - let result = instance.call("f64.i32.no_fold_trunc_u_convert_u", &[Value::F64((-0.5f64))]); + let result = instance.call( + "f64.i32.no_fold_trunc_u_convert_u", + &[Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -4334,7 +5863,10 @@ fn c342_l741_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 742 fn c343_l742_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c343_l742_action_invoke"); - let result = instance.call("f32.i64.no_fold_trunc_s_convert_s", &[Value::F32((-1.5f32))]); + let result = instance.call( + "f32.i64.no_fold_trunc_s_convert_s", + &[Value::F32((-1.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-1.0f32))))); result.map(|_| ()) } @@ -4350,7 +5882,10 @@ fn c344_l743_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 744 fn c345_l744_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c345_l744_action_invoke"); - let result = instance.call("f32.i64.no_fold_trunc_u_convert_s", &[Value::F32((-0.5f32))]); + let result = instance.call( + "f32.i64.no_fold_trunc_u_convert_s", + &[Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -4366,7 +5901,10 @@ fn c346_l745_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 746 fn c347_l746_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c347_l746_action_invoke"); - let result = instance.call("f32.i64.no_fold_trunc_s_convert_u", &[Value::F32((-1.5f32))]); + let result = instance.call( + "f32.i64.no_fold_trunc_s_convert_u", + &[Value::F32((-1.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((18446744000000000000.0f32))))); result.map(|_| ()) } @@ -4382,7 +5920,10 @@ fn c348_l747_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 748 fn c349_l748_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c349_l748_action_invoke"); - let result = instance.call("f32.i64.no_fold_trunc_u_convert_u", &[Value::F32((-0.5f32))]); + let result = instance.call( + "f32.i64.no_fold_trunc_u_convert_u", + &[Value::F32((-0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -4398,7 +5939,10 @@ fn c350_l750_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 751 fn c351_l751_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c351_l751_action_invoke"); - let result = instance.call("f64.i64.no_fold_trunc_s_convert_s", &[Value::F64((-1.5f64))]); + let result = instance.call( + "f64.i64.no_fold_trunc_s_convert_s", + &[Value::F64((-1.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-1.0f64))))); result.map(|_| ()) } @@ -4414,7 +5958,10 @@ fn c352_l752_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 753 fn c353_l753_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c353_l753_action_invoke"); - let result = instance.call("f64.i64.no_fold_trunc_u_convert_s", &[Value::F64((-0.5f64))]); + let result = instance.call( + "f64.i64.no_fold_trunc_u_convert_s", + &[Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -4430,7 +5977,10 @@ fn c354_l754_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 755 fn c355_l755_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c355_l755_action_invoke"); - let result = instance.call("f64.i64.no_fold_trunc_s_convert_u", &[Value::F64((-1.5f64))]); + let result = instance.call( + "f64.i64.no_fold_trunc_s_convert_u", + &[Value::F64((-1.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((18446744073709552000.0f64))))); result.map(|_| ()) } @@ -4446,7 +5996,10 @@ fn c356_l756_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 757 fn c357_l757_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c357_l757_action_invoke"); - let result = instance.call("f64.i64.no_fold_trunc_u_convert_u", &[Value::F64((-0.5f64))]); + let result = instance.call( + "f64.i64.no_fold_trunc_u_convert_u", + &[Value::F64((-0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -4528,8 +6081,11 @@ fn create_module_41() -> Box { (export \"check\" (func 2))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_41(instance: &mut Instance) { @@ -4541,7 +6097,7 @@ fn start_module_41(instance: &mut Instance) { fn c359_l784_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c359_l784_action_invoke"); let result = instance.call("init", &[Value::I32(0 as i32), Value::F32((15.1f32))]); - + result.map(|_| ()) } @@ -4549,7 +6105,7 @@ fn c359_l784_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c360_l785_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c360_l785_action_invoke"); let result = instance.call("init", &[Value::I32(4 as i32), Value::F32((15.2f32))]); - + result.map(|_| ()) } @@ -4557,7 +6113,7 @@ fn c360_l785_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c361_l786_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c361_l786_action_invoke"); let result = instance.call("init", &[Value::I32(8 as i32), Value::F32((15.3f32))]); - + result.map(|_| ()) } @@ -4565,7 +6121,7 @@ fn c361_l786_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c362_l787_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c362_l787_action_invoke"); let result = instance.call("init", &[Value::I32(12 as i32), Value::F32((15.4f32))]); - + result.map(|_| ()) } @@ -4605,7 +6161,7 @@ fn c366_l791_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c367_l792_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c367_l792_action_invoke"); let result = instance.call("run", &[Value::I32(16 as i32), Value::F32((3.0f32))]); - + result.map(|_| ()) } @@ -4699,8 +6255,11 @@ fn create_module_42() -> Box { (export \"check\" (func 2))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_42(instance: &mut Instance) { @@ -4712,7 +6271,7 @@ fn start_module_42(instance: &mut Instance) { fn c373_l819_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c373_l819_action_invoke"); let result = instance.call("init", &[Value::I32(0 as i32), Value::F64((15.1f64))]); - + result.map(|_| ()) } @@ -4720,7 +6279,7 @@ fn c373_l819_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c374_l820_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c374_l820_action_invoke"); let result = instance.call("init", &[Value::I32(8 as i32), Value::F64((15.2f64))]); - + result.map(|_| ()) } @@ -4728,7 +6287,7 @@ fn c374_l820_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c375_l821_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c375_l821_action_invoke"); let result = instance.call("init", &[Value::I32(16 as i32), Value::F64((15.3f64))]); - + result.map(|_| ()) } @@ -4736,7 +6295,7 @@ fn c375_l821_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c376_l822_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c376_l822_action_invoke"); let result = instance.call("init", &[Value::I32(24 as i32), Value::F64((15.4f64))]); - + result.map(|_| ()) } @@ -4776,7 +6335,7 @@ fn c380_l826_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c381_l827_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c381_l827_action_invoke"); let result = instance.call("run", &[Value::I32(32 as i32), Value::F64((3.0f64))]); - + result.map(|_| ()) } @@ -4887,8 +6446,11 @@ fn create_module_43() -> Box { (export \"f64.uge\" (func 7))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_43(instance: &mut Instance) { @@ -4923,7 +6485,10 @@ fn c389_l849_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 850 fn c390_l850_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c390_l850_action_invoke"); - let result = instance.call("f32.ult", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.ult", + &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4955,7 +6520,10 @@ fn c393_l853_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 854 fn c394_l854_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c394_l854_action_invoke"); - let result = instance.call("f32.ule", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.ule", + &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -4987,7 +6555,10 @@ fn c397_l857_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 858 fn c398_l858_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c398_l858_action_invoke"); - let result = instance.call("f32.ugt", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.ugt", + &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5019,7 +6590,10 @@ fn c401_l861_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 862 fn c402_l862_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c402_l862_action_invoke"); - let result = instance.call("f32.uge", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.uge", + &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5051,7 +6625,13 @@ fn c405_l865_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 866 fn c406_l866_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c406_l866_action_invoke"); - let result = instance.call("f64.ult", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.ult", + &[ + Value::F64((2.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5083,7 +6663,13 @@ fn c409_l869_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 870 fn c410_l870_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c410_l870_action_invoke"); - let result = instance.call("f64.ule", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.ule", + &[ + Value::F64((2.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5115,7 +6701,13 @@ fn c413_l873_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 874 fn c414_l874_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c414_l874_action_invoke"); - let result = instance.call("f64.ugt", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.ugt", + &[ + Value::F64((2.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5147,7 +6739,13 @@ fn c417_l877_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 878 fn c418_l878_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c418_l878_action_invoke"); - let result = instance.call("f64.uge", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.uge", + &[ + Value::F64((2.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -5262,8 +6860,11 @@ fn create_module_44() -> Box { (export \"f64.no_fold_ge_select\" (func 7))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_44(instance: &mut Instance) { @@ -5274,21 +6875,30 @@ fn start_module_44(instance: &mut Instance) { // Line 894 fn c420_l894_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c420_l894_action_invoke"); - let result = instance.call("f32.no_fold_lt_select", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_fold_lt_select", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 895 fn c421_l895_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c421_l895_action_invoke"); - let result = instance.call("f32.no_fold_lt_select", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_lt_select", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5296,7 +6906,10 @@ fn c421_l895_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 896 fn c422_l896_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c422_l896_action_invoke"); - let result = instance.call("f32.no_fold_lt_select", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "f32.no_fold_lt_select", + &[Value::F32((0.0f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -5304,7 +6917,10 @@ fn c422_l896_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 897 fn c423_l897_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c423_l897_action_invoke"); - let result = instance.call("f32.no_fold_lt_select", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_lt_select", + &[Value::F32((-0.0f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5312,21 +6928,30 @@ fn c423_l897_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 898 fn c424_l898_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c424_l898_action_invoke"); - let result = instance.call("f32.no_fold_le_select", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_fold_le_select", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 899 fn c425_l899_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c425_l899_action_invoke"); - let result = instance.call("f32.no_fold_le_select", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_le_select", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5334,7 +6959,10 @@ fn c425_l899_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 900 fn c426_l900_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c426_l900_action_invoke"); - let result = instance.call("f32.no_fold_le_select", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "f32.no_fold_le_select", + &[Value::F32((0.0f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5342,7 +6970,10 @@ fn c426_l900_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 901 fn c427_l901_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c427_l901_action_invoke"); - let result = instance.call("f32.no_fold_le_select", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_le_select", + &[Value::F32((-0.0f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -5350,21 +6981,30 @@ fn c427_l901_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 902 fn c428_l902_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c428_l902_action_invoke"); - let result = instance.call("f32.no_fold_gt_select", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_fold_gt_select", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 903 fn c429_l903_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c429_l903_action_invoke"); - let result = instance.call("f32.no_fold_gt_select", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_gt_select", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5372,7 +7012,10 @@ fn c429_l903_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 904 fn c430_l904_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c430_l904_action_invoke"); - let result = instance.call("f32.no_fold_gt_select", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "f32.no_fold_gt_select", + &[Value::F32((0.0f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -5380,7 +7023,10 @@ fn c430_l904_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 905 fn c431_l905_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c431_l905_action_invoke"); - let result = instance.call("f32.no_fold_gt_select", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_gt_select", + &[Value::F32((-0.0f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5388,21 +7034,30 @@ fn c431_l905_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 906 fn c432_l906_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c432_l906_action_invoke"); - let result = instance.call("f32.no_fold_ge_select", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_fold_ge_select", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 907 fn c433_l907_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c433_l907_action_invoke"); - let result = instance.call("f32.no_fold_ge_select", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_ge_select", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5410,7 +7065,10 @@ fn c433_l907_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 908 fn c434_l908_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c434_l908_action_invoke"); - let result = instance.call("f32.no_fold_ge_select", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "f32.no_fold_ge_select", + &[Value::F32((0.0f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5418,7 +7076,10 @@ fn c434_l908_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 909 fn c435_l909_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c435_l909_action_invoke"); - let result = instance.call("f32.no_fold_ge_select", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_ge_select", + &[Value::F32((-0.0f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -5426,21 +7087,36 @@ fn c435_l909_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 910 fn c436_l910_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c436_l910_action_invoke"); - let result = instance.call("f64.no_fold_lt_select", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_fold_lt_select", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 911 fn c437_l911_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c437_l911_action_invoke"); - let result = instance.call("f64.no_fold_lt_select", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_lt_select", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5448,7 +7124,10 @@ fn c437_l911_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 912 fn c438_l912_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c438_l912_action_invoke"); - let result = instance.call("f64.no_fold_lt_select", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "f64.no_fold_lt_select", + &[Value::F64((0.0f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -5456,7 +7135,10 @@ fn c438_l912_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 913 fn c439_l913_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c439_l913_action_invoke"); - let result = instance.call("f64.no_fold_lt_select", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_lt_select", + &[Value::F64((-0.0f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5464,21 +7146,36 @@ fn c439_l913_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 914 fn c440_l914_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c440_l914_action_invoke"); - let result = instance.call("f64.no_fold_le_select", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_fold_le_select", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 915 fn c441_l915_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c441_l915_action_invoke"); - let result = instance.call("f64.no_fold_le_select", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_le_select", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5486,7 +7183,10 @@ fn c441_l915_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 916 fn c442_l916_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c442_l916_action_invoke"); - let result = instance.call("f64.no_fold_le_select", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "f64.no_fold_le_select", + &[Value::F64((0.0f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5494,7 +7194,10 @@ fn c442_l916_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 917 fn c443_l917_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c443_l917_action_invoke"); - let result = instance.call("f64.no_fold_le_select", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_le_select", + &[Value::F64((-0.0f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -5502,21 +7205,36 @@ fn c443_l917_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 918 fn c444_l918_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c444_l918_action_invoke"); - let result = instance.call("f64.no_fold_gt_select", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_fold_gt_select", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 919 fn c445_l919_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c445_l919_action_invoke"); - let result = instance.call("f64.no_fold_gt_select", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_gt_select", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5524,7 +7242,10 @@ fn c445_l919_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 920 fn c446_l920_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c446_l920_action_invoke"); - let result = instance.call("f64.no_fold_gt_select", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "f64.no_fold_gt_select", + &[Value::F64((0.0f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -5532,7 +7253,10 @@ fn c446_l920_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 921 fn c447_l921_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c447_l921_action_invoke"); - let result = instance.call("f64.no_fold_gt_select", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_gt_select", + &[Value::F64((-0.0f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5540,21 +7264,36 @@ fn c447_l921_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 922 fn c448_l922_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c448_l922_action_invoke"); - let result = instance.call("f64.no_fold_ge_select", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_fold_ge_select", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 923 fn c449_l923_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c449_l923_action_invoke"); - let result = instance.call("f64.no_fold_ge_select", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_ge_select", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5562,7 +7301,10 @@ fn c449_l923_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 924 fn c450_l924_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c450_l924_action_invoke"); - let result = instance.call("f64.no_fold_ge_select", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "f64.no_fold_ge_select", + &[Value::F64((0.0f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5570,7 +7312,10 @@ fn c450_l924_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 925 fn c451_l925_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c451_l925_action_invoke"); - let result = instance.call("f64.no_fold_ge_select", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_ge_select", + &[Value::F64((-0.0f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -5701,8 +7446,11 @@ fn create_module_45() -> Box { (export \"f64.no_fold_ge_if\" (func 7))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_45(instance: &mut Instance) { @@ -5713,21 +7461,30 @@ fn start_module_45(instance: &mut Instance) { // Line 973 fn c453_l973_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c453_l973_action_invoke"); - let result = instance.call("f32.no_fold_lt_if", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_fold_lt_if", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 974 fn c454_l974_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c454_l974_action_invoke"); - let result = instance.call("f32.no_fold_lt_if", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_lt_if", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5735,7 +7492,10 @@ fn c454_l974_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 975 fn c455_l975_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c455_l975_action_invoke"); - let result = instance.call("f32.no_fold_lt_if", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "f32.no_fold_lt_if", + &[Value::F32((0.0f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -5743,7 +7503,10 @@ fn c455_l975_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 976 fn c456_l976_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c456_l976_action_invoke"); - let result = instance.call("f32.no_fold_lt_if", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_lt_if", + &[Value::F32((-0.0f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5751,21 +7514,30 @@ fn c456_l976_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 977 fn c457_l977_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c457_l977_action_invoke"); - let result = instance.call("f32.no_fold_le_if", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_fold_le_if", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 978 fn c458_l978_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c458_l978_action_invoke"); - let result = instance.call("f32.no_fold_le_if", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_le_if", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5773,7 +7545,10 @@ fn c458_l978_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 979 fn c459_l979_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c459_l979_action_invoke"); - let result = instance.call("f32.no_fold_le_if", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "f32.no_fold_le_if", + &[Value::F32((0.0f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5781,7 +7556,10 @@ fn c459_l979_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 980 fn c460_l980_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c460_l980_action_invoke"); - let result = instance.call("f32.no_fold_le_if", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_le_if", + &[Value::F32((-0.0f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -5789,21 +7567,30 @@ fn c460_l980_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 981 fn c461_l981_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c461_l981_action_invoke"); - let result = instance.call("f32.no_fold_gt_if", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_fold_gt_if", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 982 fn c462_l982_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c462_l982_action_invoke"); - let result = instance.call("f32.no_fold_gt_if", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_gt_if", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5811,7 +7598,10 @@ fn c462_l982_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 983 fn c463_l983_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c463_l983_action_invoke"); - let result = instance.call("f32.no_fold_gt_if", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "f32.no_fold_gt_if", + &[Value::F32((0.0f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -5819,7 +7609,10 @@ fn c463_l983_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 984 fn c464_l984_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c464_l984_action_invoke"); - let result = instance.call("f32.no_fold_gt_if", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_gt_if", + &[Value::F32((-0.0f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5827,21 +7620,30 @@ fn c464_l984_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 985 fn c465_l985_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c465_l985_action_invoke"); - let result = instance.call("f32.no_fold_ge_if", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_fold_ge_if", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 986 fn c466_l986_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c466_l986_action_invoke"); - let result = instance.call("f32.no_fold_ge_if", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_ge_if", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5849,7 +7651,10 @@ fn c466_l986_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 987 fn c467_l987_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c467_l987_action_invoke"); - let result = instance.call("f32.no_fold_ge_if", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "f32.no_fold_ge_if", + &[Value::F32((0.0f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -5857,7 +7662,10 @@ fn c467_l987_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 988 fn c468_l988_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c468_l988_action_invoke"); - let result = instance.call("f32.no_fold_ge_if", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_ge_if", + &[Value::F32((-0.0f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -5865,21 +7673,36 @@ fn c468_l988_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 989 fn c469_l989_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c469_l989_action_invoke"); - let result = instance.call("f64.no_fold_lt_if", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_fold_lt_if", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 990 fn c470_l990_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c470_l990_action_invoke"); - let result = instance.call("f64.no_fold_lt_if", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_lt_if", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5887,7 +7710,10 @@ fn c470_l990_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 991 fn c471_l991_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c471_l991_action_invoke"); - let result = instance.call("f64.no_fold_lt_if", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "f64.no_fold_lt_if", + &[Value::F64((0.0f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -5895,7 +7721,10 @@ fn c471_l991_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 992 fn c472_l992_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c472_l992_action_invoke"); - let result = instance.call("f64.no_fold_lt_if", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_lt_if", + &[Value::F64((-0.0f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5903,21 +7732,36 @@ fn c472_l992_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 993 fn c473_l993_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c473_l993_action_invoke"); - let result = instance.call("f64.no_fold_le_if", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_fold_le_if", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 994 fn c474_l994_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c474_l994_action_invoke"); - let result = instance.call("f64.no_fold_le_if", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_le_if", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5925,7 +7769,10 @@ fn c474_l994_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 995 fn c475_l995_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c475_l995_action_invoke"); - let result = instance.call("f64.no_fold_le_if", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "f64.no_fold_le_if", + &[Value::F64((0.0f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5933,7 +7780,10 @@ fn c475_l995_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 996 fn c476_l996_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c476_l996_action_invoke"); - let result = instance.call("f64.no_fold_le_if", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_le_if", + &[Value::F64((-0.0f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -5941,21 +7791,36 @@ fn c476_l996_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 997 fn c477_l997_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c477_l997_action_invoke"); - let result = instance.call("f64.no_fold_gt_if", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_fold_gt_if", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 998 fn c478_l998_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c478_l998_action_invoke"); - let result = instance.call("f64.no_fold_gt_if", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_gt_if", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5963,7 +7828,10 @@ fn c478_l998_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 999 fn c479_l999_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c479_l999_action_invoke"); - let result = instance.call("f64.no_fold_gt_if", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "f64.no_fold_gt_if", + &[Value::F64((0.0f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -5971,7 +7839,10 @@ fn c479_l999_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1000 fn c480_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c480_l1000_action_invoke"); - let result = instance.call("f64.no_fold_gt_if", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_gt_if", + &[Value::F64((-0.0f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -5979,21 +7850,36 @@ fn c480_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1001 fn c481_l1001_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c481_l1001_action_invoke"); - let result = instance.call("f64.no_fold_ge_if", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_fold_ge_if", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1002 fn c482_l1002_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c482_l1002_action_invoke"); - let result = instance.call("f64.no_fold_ge_if", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_ge_if", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -6001,7 +7887,10 @@ fn c482_l1002_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1003 fn c483_l1003_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c483_l1003_action_invoke"); - let result = instance.call("f64.no_fold_ge_if", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "f64.no_fold_ge_if", + &[Value::F64((0.0f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -6009,7 +7898,10 @@ fn c483_l1003_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1004 fn c484_l1004_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c484_l1004_action_invoke"); - let result = instance.call("f64.no_fold_ge_if", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_ge_if", + &[Value::F64((-0.0f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -6132,8 +8024,11 @@ fn create_module_46() -> Box { (export \"f64.no_fold_ge_select_to_abs\" (func 7))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_46(instance: &mut Instance) { @@ -6144,28 +8039,40 @@ fn start_module_46(instance: &mut Instance) { // Line 1020 fn c486_l1020_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c486_l1020_action_invoke"); - let result = instance.call("f32.no_fold_lt_select_to_abs", &[Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "f32.no_fold_lt_select_to_abs", + &[Value::F32(f32::from_bits(2141192192))], + ); let expected = f32::from_bits(2141192192); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1021 fn c487_l1021_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c487_l1021_action_invoke"); - let result = instance.call("f32.no_fold_lt_select_to_abs", &[Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "f32.no_fold_lt_select_to_abs", + &[Value::F32(f32::from_bits(4290772992))], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6188,28 +8095,40 @@ fn c489_l1023_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1024 fn c490_l1024_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c490_l1024_action_invoke"); - let result = instance.call("f32.no_fold_le_select_to_abs", &[Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "f32.no_fold_le_select_to_abs", + &[Value::F32(f32::from_bits(2141192192))], + ); let expected = f32::from_bits(2141192192); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1025 fn c491_l1025_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c491_l1025_action_invoke"); - let result = instance.call("f32.no_fold_le_select_to_abs", &[Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "f32.no_fold_le_select_to_abs", + &[Value::F32(f32::from_bits(4290772992))], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6232,28 +8151,40 @@ fn c493_l1027_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1028 fn c494_l1028_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c494_l1028_action_invoke"); - let result = instance.call("f32.no_fold_gt_select_to_abs", &[Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "f32.no_fold_gt_select_to_abs", + &[Value::F32(f32::from_bits(2141192192))], + ); let expected = f32::from_bits(4288675840); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1029 fn c495_l1029_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c495_l1029_action_invoke"); - let result = instance.call("f32.no_fold_gt_select_to_abs", &[Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "f32.no_fold_gt_select_to_abs", + &[Value::F32(f32::from_bits(4290772992))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6276,28 +8207,40 @@ fn c497_l1031_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1032 fn c498_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c498_l1032_action_invoke"); - let result = instance.call("f32.no_fold_ge_select_to_abs", &[Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "f32.no_fold_ge_select_to_abs", + &[Value::F32(f32::from_bits(2141192192))], + ); let expected = f32::from_bits(4288675840); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1033 fn c499_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c499_l1033_action_invoke"); - let result = instance.call("f32.no_fold_ge_select_to_abs", &[Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "f32.no_fold_ge_select_to_abs", + &[Value::F32(f32::from_bits(4290772992))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6320,28 +8263,40 @@ fn c501_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1036 fn c502_l1036_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c502_l1036_action_invoke"); - let result = instance.call("f64.no_fold_lt_select_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "f64.no_fold_lt_select_to_abs", + &[Value::F64(f64::from_bits(9219994337134247936))], + ); let expected = f64::from_bits(9219994337134247936); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1037 fn c503_l1037_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c503_l1037_action_invoke"); - let result = instance.call("f64.no_fold_lt_select_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "f64.no_fold_lt_select_to_abs", + &[Value::F64(f64::from_bits(18444492273895866368))], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6364,28 +8319,40 @@ fn c505_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1040 fn c506_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c506_l1040_action_invoke"); - let result = instance.call("f64.no_fold_le_select_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "f64.no_fold_le_select_to_abs", + &[Value::F64(f64::from_bits(9219994337134247936))], + ); let expected = f64::from_bits(9219994337134247936); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1041 fn c507_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c507_l1041_action_invoke"); - let result = instance.call("f64.no_fold_le_select_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "f64.no_fold_le_select_to_abs", + &[Value::F64(f64::from_bits(18444492273895866368))], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6408,28 +8375,40 @@ fn c509_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1044 fn c510_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c510_l1044_action_invoke"); - let result = instance.call("f64.no_fold_gt_select_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "f64.no_fold_gt_select_to_abs", + &[Value::F64(f64::from_bits(9219994337134247936))], + ); let expected = f64::from_bits(18443366373989023744); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1045 fn c511_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c511_l1045_action_invoke"); - let result = instance.call("f64.no_fold_gt_select_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "f64.no_fold_gt_select_to_abs", + &[Value::F64(f64::from_bits(18444492273895866368))], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6452,28 +8431,40 @@ fn c513_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1048 fn c514_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c514_l1048_action_invoke"); - let result = instance.call("f64.no_fold_ge_select_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "f64.no_fold_ge_select_to_abs", + &[Value::F64(f64::from_bits(9219994337134247936))], + ); let expected = f64::from_bits(18443366373989023744); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1049 fn c515_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c515_l1049_action_invoke"); - let result = instance.call("f64.no_fold_ge_select_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "f64.no_fold_ge_select_to_abs", + &[Value::F64(f64::from_bits(18444492273895866368))], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6627,8 +8618,11 @@ fn create_module_47() -> Box { (export \"f64.no_fold_ge_if_to_abs\" (func 7))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_47(instance: &mut Instance) { @@ -6639,28 +8633,40 @@ fn start_module_47(instance: &mut Instance) { // Line 1099 fn c519_l1099_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c519_l1099_action_invoke"); - let result = instance.call("f32.no_fold_lt_if_to_abs", &[Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "f32.no_fold_lt_if_to_abs", + &[Value::F32(f32::from_bits(2141192192))], + ); let expected = f32::from_bits(2141192192); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1100 fn c520_l1100_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c520_l1100_action_invoke"); - let result = instance.call("f32.no_fold_lt_if_to_abs", &[Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "f32.no_fold_lt_if_to_abs", + &[Value::F32(f32::from_bits(4290772992))], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6683,28 +8689,40 @@ fn c522_l1102_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1103 fn c523_l1103_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c523_l1103_action_invoke"); - let result = instance.call("f32.no_fold_le_if_to_abs", &[Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "f32.no_fold_le_if_to_abs", + &[Value::F32(f32::from_bits(2141192192))], + ); let expected = f32::from_bits(2141192192); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1104 fn c524_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c524_l1104_action_invoke"); - let result = instance.call("f32.no_fold_le_if_to_abs", &[Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "f32.no_fold_le_if_to_abs", + &[Value::F32(f32::from_bits(4290772992))], + ); let expected = f32::from_bits(4290772992); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6727,28 +8745,40 @@ fn c526_l1106_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1107 fn c527_l1107_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c527_l1107_action_invoke"); - let result = instance.call("f32.no_fold_gt_if_to_abs", &[Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "f32.no_fold_gt_if_to_abs", + &[Value::F32(f32::from_bits(2141192192))], + ); let expected = f32::from_bits(4288675840); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1108 fn c528_l1108_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c528_l1108_action_invoke"); - let result = instance.call("f32.no_fold_gt_if_to_abs", &[Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "f32.no_fold_gt_if_to_abs", + &[Value::F32(f32::from_bits(4290772992))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6771,28 +8801,40 @@ fn c530_l1110_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1111 fn c531_l1111_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c531_l1111_action_invoke"); - let result = instance.call("f32.no_fold_ge_if_to_abs", &[Value::F32(f32::from_bits(2141192192))]); + let result = instance.call( + "f32.no_fold_ge_if_to_abs", + &[Value::F32(f32::from_bits(2141192192))], + ); let expected = f32::from_bits(4288675840); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1112 fn c532_l1112_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c532_l1112_action_invoke"); - let result = instance.call("f32.no_fold_ge_if_to_abs", &[Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "f32.no_fold_ge_if_to_abs", + &[Value::F32(f32::from_bits(4290772992))], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6815,28 +8857,40 @@ fn c534_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1115 fn c535_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c535_l1115_action_invoke"); - let result = instance.call("f64.no_fold_lt_if_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "f64.no_fold_lt_if_to_abs", + &[Value::F64(f64::from_bits(9219994337134247936))], + ); let expected = f64::from_bits(9219994337134247936); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1116 fn c536_l1116_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c536_l1116_action_invoke"); - let result = instance.call("f64.no_fold_lt_if_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "f64.no_fold_lt_if_to_abs", + &[Value::F64(f64::from_bits(18444492273895866368))], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6859,28 +8913,40 @@ fn c538_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1119 fn c539_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c539_l1119_action_invoke"); - let result = instance.call("f64.no_fold_le_if_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "f64.no_fold_le_if_to_abs", + &[Value::F64(f64::from_bits(9219994337134247936))], + ); let expected = f64::from_bits(9219994337134247936); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1120 fn c540_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c540_l1120_action_invoke"); - let result = instance.call("f64.no_fold_le_if_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "f64.no_fold_le_if_to_abs", + &[Value::F64(f64::from_bits(18444492273895866368))], + ); let expected = f64::from_bits(18444492273895866368); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6903,28 +8969,40 @@ fn c542_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1123 fn c543_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c543_l1123_action_invoke"); - let result = instance.call("f64.no_fold_gt_if_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "f64.no_fold_gt_if_to_abs", + &[Value::F64(f64::from_bits(9219994337134247936))], + ); let expected = f64::from_bits(18443366373989023744); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1124 fn c544_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c544_l1124_action_invoke"); - let result = instance.call("f64.no_fold_gt_if_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "f64.no_fold_gt_if_to_abs", + &[Value::F64(f64::from_bits(18444492273895866368))], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -6947,28 +9025,40 @@ fn c546_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1127 fn c547_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c547_l1127_action_invoke"); - let result = instance.call("f64.no_fold_ge_if_to_abs", &[Value::F64(f64::from_bits(9219994337134247936))]); + let result = instance.call( + "f64.no_fold_ge_if_to_abs", + &[Value::F64(f64::from_bits(9219994337134247936))], + ); let expected = f64::from_bits(18443366373989023744); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 1128 fn c548_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c548_l1128_action_invoke"); - let result = instance.call("f64.no_fold_ge_if_to_abs", &[Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "f64.no_fold_ge_if_to_abs", + &[Value::F64(f64::from_bits(18444492273895866368))], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -7052,8 +9142,11 @@ fn create_module_48() -> Box { (export \"f64.incorrect_correction\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_48(instance: &mut Instance) { @@ -7073,7 +9166,10 @@ fn c552_l1144_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c553_l1145_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c553_l1145_action_invoke"); let result = instance.call("f64.incorrect_correction", &[]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000002220446049250313f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((-0.0000000000000002220446049250313f64)))) + ); result.map(|_| ()) } @@ -7131,8 +9227,11 @@ fn create_module_49() -> Box { (export \"calculate\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_49(instance: &mut Instance) { @@ -7201,8 +9300,11 @@ fn create_module_50() -> Box { (export \"calculate\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_50(instance: &mut Instance) { @@ -7239,8 +9341,11 @@ fn create_module_51() -> Box { (export \"llvm_pr26746\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_51(instance: &mut Instance) { @@ -7278,8 +9383,11 @@ fn create_module_52() -> Box { (export \"llvm_pr27153\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_52(instance: &mut Instance) { @@ -7320,8 +9428,11 @@ fn create_module_53() -> Box { (export \"llvm_pr27036\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_53(instance: &mut Instance) { @@ -7332,7 +9443,10 @@ fn start_module_53(instance: &mut Instance) { // Line 1220 fn c563_l1220_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c563_l1220_action_invoke"); - let result = instance.call("llvm_pr27036", &[Value::I32(-25034805 as i32), Value::I32(14942208 as i32)]); + let result = instance.call( + "llvm_pr27036", + &[Value::I32(-25034805 as i32), Value::I32(14942208 as i32)], + ); assert_eq!(result, Ok(Some(Value::F32((-10092596.0f32))))); result.map(|_| ()) } @@ -7376,8 +9490,11 @@ fn create_module_54() -> Box { (export \"thepast2\" (func 2))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_54(instance: &mut Instance) { @@ -7396,16 +9513,40 @@ fn c565_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1245 fn c566_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c566_l1245_action_invoke"); - let result = instance.call("thepast1", &[Value::F64((0.00000000000000005551115123125783f64)), Value::F64((0.9999999999999999f64)), Value::F64((0.00000000000000005551115123125783f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000006162975822039155f64))))); + let result = instance.call( + "thepast1", + &[ + Value::F64((0.00000000000000005551115123125783f64)), + Value::F64((0.9999999999999999f64)), + Value::F64((0.00000000000000005551115123125783f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.000000000000000000000000000000006162975822039155f64) + ))) + ); result.map(|_| ()) } // Line 1246 fn c567_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c567_l1246_action_invoke"); - let result = instance.call("thepast2", &[Value::F32((0.000000000000000000000000000000000000023509887f32)), Value::F32((0.5f32)), Value::F32((1.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "thepast2", + &[ + Value::F32((0.000000000000000000000000000000000000023509887f32)), + Value::F32((0.5f32)), + Value::F32((1.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } @@ -7430,8 +9571,11 @@ fn create_module_55() -> Box { (export \"inverse\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_55(instance: &mut Instance) { @@ -7474,8 +9618,11 @@ fn create_module_56() -> Box { (export \"f64_sqrt_minus_2\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_56(instance: &mut Instance) { @@ -7529,8 +9676,11 @@ fn create_module_57() -> Box { (export \"f64.no_fold_recip_recip\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_57(instance: &mut Instance) { @@ -7541,7 +9691,10 @@ fn start_module_57(instance: &mut Instance) { // Line 1285 fn c574_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c574_l1285_action_invoke"); - let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((-70435790000000000000.0f32))]); + let result = instance.call( + "f32.no_fold_recip_recip", + &[Value::F32((-70435790000000000000.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-70435784000000000000.0f32))))); result.map(|_| ()) } @@ -7549,16 +9702,28 @@ fn c574_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1286 fn c575_l1286_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c575_l1286_action_invoke"); - let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((0.000000000000000000000012466101f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000124661f32))))); + let result = instance.call( + "f32.no_fold_recip_recip", + &[Value::F32((0.000000000000000000000012466101f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.0000000000000000000000124661f32)))) + ); result.map(|_| ()) } // Line 1287 fn c576_l1287_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c576_l1287_action_invoke"); - let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((0.000000000000000000097184545f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000009718455f32))))); + let result = instance.call( + "f32.no_fold_recip_recip", + &[Value::F32((0.000000000000000000097184545f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.00000000000000000009718455f32)))) + ); result.map(|_| ()) } @@ -7573,7 +9738,10 @@ fn c577_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1289 fn c578_l1289_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c578_l1289_action_invoke"); - let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((2331659200000000000000.0f32))]); + let result = instance.call( + "f32.no_fold_recip_recip", + &[Value::F32((2331659200000000000000.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((2331659000000000000000.0f32))))); result.map(|_| ()) } @@ -7613,15 +9781,28 @@ fn c582_l1294_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1296 fn c583_l1296_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c583_l1296_action_invoke"); - let result = instance.call("f64.no_fold_recip_recip", &[Value::F64((-657971534362886860000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-657971534362886900000000000000000000000000000.0f64))))); + let result = instance.call( + "f64.no_fold_recip_recip", + &[Value::F64( + (-657971534362886860000000000000000000000000000.0f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (-657971534362886900000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } // Line 1297 fn c584_l1297_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c584_l1297_action_invoke"); - let result = instance.call("f64.no_fold_recip_recip", &[Value::F64((-144246931868576430000.0f64))]); + let result = instance.call( + "f64.no_fold_recip_recip", + &[Value::F64((-144246931868576430000.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-144246931868576420000.0f64))))); result.map(|_| ()) } @@ -7629,8 +9810,18 @@ fn c584_l1297_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1298 fn c585_l1298_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c585_l1298_action_invoke"); - let result = instance.call("f64.no_fold_recip_recip", &[Value::F64((184994689206231350000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((184994689206231330000000000000000000000000000000000.0f64))))); + let result = instance.call( + "f64.no_fold_recip_recip", + &[Value::F64( + (184994689206231350000000000000000000000000000000000.0f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (184994689206231330000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -7732,8 +9923,11 @@ fn create_module_58() -> Box { (export \"f64.no_algebraic_factoring\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_58(instance: &mut Instance) { @@ -7744,15 +9938,29 @@ fn start_module_58(instance: &mut Instance) { // Line 1319 fn c593_l1319_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c593_l1319_action_invoke"); - let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((-0.000000000000000053711865f32)), Value::F32((0.00000000000000009744328f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000006610229f32))))); + let result = instance.call( + "f32.no_algebraic_factoring", + &[ + Value::F32((-0.000000000000000053711865f32)), + Value::F32((0.00000000000000009744328f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000006610229f32) + ))) + ); result.map(|_| ()) } // Line 1320 fn c594_l1320_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c594_l1320_action_invoke"); - let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((-19756732.0f32)), Value::F32((32770204.0f32))]); + let result = instance.call( + "f32.no_algebraic_factoring", + &[Value::F32((-19756732.0f32)), Value::F32((32770204.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-683557800000000.0f32))))); result.map(|_| ()) } @@ -7760,15 +9968,27 @@ fn c594_l1320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1321 fn c595_l1321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c595_l1321_action_invoke"); - let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((52314150000000.0f32)), Value::F32((-145309980000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-18378221000000000000000000000.0f32))))); + let result = instance.call( + "f32.no_algebraic_factoring", + &[ + Value::F32((52314150000000.0f32)), + Value::F32((-145309980000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-18378221000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 1322 fn c596_l1322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c596_l1322_action_invoke"); - let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((195260.38f32)), Value::F32((-227.75723f32))]); + let result = instance.call( + "f32.no_algebraic_factoring", + &[Value::F32((195260.38f32)), Value::F32((-227.75723f32))], + ); assert_eq!(result, Ok(Some(Value::F32((38126563000.0f32))))); result.map(|_| ()) } @@ -7776,7 +9996,10 @@ fn c596_l1322_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1323 fn c597_l1323_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c597_l1323_action_invoke"); - let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((-237.48706f32)), Value::F32((-972341.5f32))]); + let result = instance.call( + "f32.no_algebraic_factoring", + &[Value::F32((-237.48706f32)), Value::F32((-972341.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-945447960000.0f32))))); result.map(|_| ()) } @@ -7808,7 +10031,13 @@ fn c600_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1328 fn c601_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c601_l1328_action_invoke"); - let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((-1292099281007814900000000000000000000000000000000000000.0f64)), Value::F64((662717187728034000000000000000000000000000000000000000000.0f64))]); + let result = instance.call( + "f64.no_algebraic_factoring", + &[ + Value::F64((-1292099281007814900000000000000000000000000000000000000.0f64)), + Value::F64((662717187728034000000000000000000000000000000000000000000.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-439192401389602300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))))); result.map(|_| ()) } @@ -7816,8 +10045,19 @@ fn c601_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1329 fn c602_l1329_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c602_l1329_action_invoke"); - let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((26242795689010570000000000000000000.0f64)), Value::F64((-1625023398605080200000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((688684325575149100000000000000000000000000000000000000000000000000000.0f64))))); + let result = instance.call( + "f64.no_algebraic_factoring", + &[ + Value::F64((26242795689010570000000000000000000.0f64)), + Value::F64((-1625023398605080200000000000.0f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (688684325575149100000000000000000000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -7863,8 +10103,11 @@ fn create_module_59() -> Box { (export \"f64.no_algebraic_factoring\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_59(instance: &mut Instance) { @@ -7875,23 +10118,47 @@ fn start_module_59(instance: &mut Instance) { // Line 1343 fn c604_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c604_l1343_action_invoke"); - let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((0.000000000000022102996f32)), Value::F32((0.0000000000031465275f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000099001476f32))))); + let result = instance.call( + "f32.no_algebraic_factoring", + &[ + Value::F32((0.000000000000022102996f32)), + Value::F32((0.0000000000031465275f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-0.0000000000000000000000099001476f32)))) + ); result.map(|_| ()) } // Line 1344 fn c605_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c605_l1344_action_invoke"); - let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((-3289460800000.0f32)), Value::F32((-15941539000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((10820299000000000000000000.0f32))))); + let result = instance.call( + "f32.no_algebraic_factoring", + &[ + Value::F32((-3289460800000.0f32)), + Value::F32((-15941539000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((10820299000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 1345 fn c606_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c606_l1345_action_invoke"); - let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((0.00036497542f32)), Value::F32((-0.00016153714f32))]); + let result = instance.call( + "f32.no_algebraic_factoring", + &[ + Value::F32((0.00036497542f32)), + Value::F32((-0.00016153714f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.000000107112804f32))))); result.map(|_| ()) } @@ -7899,16 +10166,34 @@ fn c606_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1346 fn c607_l1346_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c607_l1346_action_invoke"); - let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((0.000000000000065383266f32)), Value::F32((-0.000000000000027412773f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000003523511f32))))); + let result = instance.call( + "f32.no_algebraic_factoring", + &[ + Value::F32((0.000000000000065383266f32)), + Value::F32((-0.000000000000027412773f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.000000000000000000000000003523511f32)))) + ); result.map(|_| ()) } // Line 1347 fn c608_l1347_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c608_l1347_action_invoke"); - let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((3609682000000000.0f32)), Value::F32((-5260104400000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-14638896000000000000000000000000.0f32))))); + let result = instance.call( + "f32.no_algebraic_factoring", + &[ + Value::F32((3609682000000000.0f32)), + Value::F32((-5260104400000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-14638896000000000000000000000000.0f32)))) + ); result.map(|_| ()) } @@ -7931,15 +10216,30 @@ fn c610_l1350_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1351 fn c611_l1351_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c611_l1351_action_invoke"); - let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((5477733829752.252f64)), Value::F64((-970738900948.5906f64))]); - assert_eq!(result, Ok(Some(Value::F64((29063233895797397000000000.0f64))))); + let result = instance.call( + "f64.no_algebraic_factoring", + &[ + Value::F64((5477733829752.252f64)), + Value::F64((-970738900948.5906f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64((29063233895797397000000000.0f64)))) + ); result.map(|_| ()) } // Line 1352 fn c612_l1352_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c612_l1352_action_invoke"); - let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((-10689141744923551000000000000000000000000000000000000000.0f64)), Value::F64((-173378393593738040000000000000000000000000000000000.0f64))]); + let result = instance.call( + "f64.no_algebraic_factoring", + &[ + Value::F64((-10689141744923551000000000000000000000000000000000000000.0f64)), + Value::F64((-173378393593738040000000000000000000000000000000000.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((114257751213007240000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))))); result.map(|_| ()) } @@ -8029,8 +10329,11 @@ fn create_module_60() -> Box { (data (;0;) (i32.const 0) \"\\01\\00\\00\\00\\01\\00\\00\\80\\01\\00\\00\\00\\01\\00\\00\\80\\01\\00\\00\\00\\01\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_60(instance: &mut Instance) { @@ -8041,7 +10344,14 @@ fn start_module_60(instance: &mut Instance) { // Line 1391 fn c615_l1391_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c615_l1391_action_invoke"); - let result = instance.call("f32.simple_x4_sum", &[Value::I32(0 as i32), Value::I32(16 as i32), Value::I32(32 as i32)]); + let result = instance.call( + "f32.simple_x4_sum", + &[ + Value::I32(0 as i32), + Value::I32(16 as i32), + Value::I32(32 as i32), + ], + ); assert_eq!(result, Ok(None)); result.map(|_| ()) } @@ -8050,7 +10360,12 @@ fn c615_l1391_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c616_l1392_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c616_l1392_action_invoke"); let result = instance.call("f32.load", &[Value::I32(32 as i32)]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32))))); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000003f32) + ))) + ); result.map(|_| ()) } @@ -8066,7 +10381,12 @@ fn c617_l1393_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c618_l1394_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c618_l1394_action_invoke"); let result = instance.call("f32.load", &[Value::I32(40 as i32)]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } @@ -8074,7 +10394,12 @@ fn c618_l1394_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c619_l1395_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c619_l1395_action_invoke"); let result = instance.call("f32.load", &[Value::I32(44 as i32)]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32))))); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } @@ -8150,8 +10475,11 @@ fn create_module_61() -> Box { (data (;0;) (i32.const 0) \"\\01\\00\\00\\00\\00\\00\\00\\00\\01\\00\\00\\00\\00\\00\\00\\80\\01\\00\\00\\00\\00\\00\\00\\00\\01\\00\\00\\00\\00\\00\\00\\80\\01\\00\\00\\00\\00\\00\\00\\00\\01\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_61(instance: &mut Instance) { @@ -8162,7 +10490,14 @@ fn start_module_61(instance: &mut Instance) { // Line 1430 fn c621_l1430_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c621_l1430_action_invoke"); - let result = instance.call("f64.simple_x4_sum", &[Value::I32(0 as i32), Value::I32(32 as i32), Value::I32(64 as i32)]); + let result = instance.call( + "f64.simple_x4_sum", + &[ + Value::I32(0 as i32), + Value::I32(32 as i32), + Value::I32(64 as i32), + ], + ); assert_eq!(result, Ok(None)); result.map(|_| ()) } @@ -8274,8 +10609,11 @@ fn create_module_62() -> Box { (data (;0;) (i32.const 0) \"\\c4\\c5W$\\a5\\84\\c8\\0bm\\b8K.\\f2v\\17\\1c\\caJV\\1e\\1bnq\\22]\\17\\1en\\bf\\cd\\14\\5c\\c7!UQ9\\9c\\1f\\b2Q\\f0\\a3\\93\\d7\\c1,\\ae~\\a8(:\\01!\\f4\\0aX\\93\\f8Bw\\9f\\839j_\\ba\\f7\\0a\\d8Qj4\\ca\\ad\\c64\\0e\\d8&\\dcL3\\1c\\ed)\\90\\a8x\\0f\\d1\\cev1#\\83\\b85\\e8\\f2D\\b0\\d3\\a1\\fc\\bb2\\e1\\b0\\baiD\\09\\d6\\d9}\\ff.\\c0Z6\\143\\14>\\a9\\fa\\87m\\8b\\bc\\ce\\9d\\a7\\fd\\c4\\e9\\85?\\dd\\d7\\e1\\18\\a6P&rn?s\\0f\\f8\\12\\93#4av\\12H\\c0\\9b\\05\\93\\eb\\ac\\86\\de\\94>U\\e8\\8c\\e8\\dd\\e4\\fc\\95G\\beV\\03! L\\e6\\bf{\\f6\\7f\\d5\\bas\\1c\\c1\\14\\8f\\c4'\\96\\b3\\bd3\\ffxA_\\c0Z\\ce\\f6gns\\9a\\17fp\\03\\f8\\ce'\\a3R\\b2\\9f;\\bf\\fb\\ae\\ed\\d3Z\\f87W\\f0\\f5n\\ef\\b1Mp=T\\a7\\01\\9a\\85\\08H\\91\\f5\\9d\\0c`\\87[\\d9T\\1eQm\\88\\8e\\08\\8c\\a5q:V\\08gF\\8f\\8f\\13*,\\ec,\\1f\\b4b+oA\\0a\\c4eB\\a21k,}>\\bbu\\ac\\86\\970\\d9H\\cd\\9a\\1fV\\c4\\c6\\e4\\12\\c0\\9d\\fb\\ee\\02\\8c\\ce\\1c\\f2\\1e\\a1x#\\db\\c4\\1eI\\03\\d3q\\cc\\08P\\c5\\d8\\5c\\ed\\d5\\b5e\\ac\\b5\\c9!\\d2\\c9)v\\de\\f00\\1a[<\\f2;\\db:9\\82:\\16\\08o\\a8\\f1\\beii\\99q\\a6\\05\\d3\\14\\93*\\16\\f2/\\11\\c7~ \\bb\\91D\\ee\\f8\\e4\\01S\\c0\\b9\\7f\\f0\\bf\\f0\\03\\9cm\\b1\\df\\a2D\\01mkq+\\5c\\b3!\\19F^\\8f\\db\\91\\d3|xk\\b7\\12\\00\\8f\\eb\\bd\\8a\\f5\\d4.\\c4\\c1\\1e\\dfscYGI\\03\\0a\\b7\\cf$\\cf\\9c\\0eDz\\9e\\14\\fbB\\bf\\9d90\\9e\\a0\\ab/\\d1\\ae\\9ej\\83C\\e3U}\\85\\bfc\\8a\\f8\\96\\10\\1f\\fem\\e7\\22\\1b\\e1iF\\8aD\\c8\\c8\\f9\\0c+\\19\\07\\a5\\02>\\f20\\10\\9a\\85\\8a_\\ef\\81E\\a0w\\b1\\03\\10sK\\ae\\98\\9dG\\bf\\9a-:\\d5\\0f\\03f\\e3=S\\d9@\\ce\\1fo2/!+#!lb\\d4\\a7>\\a8\\ce(1-\\00=g^\\af\\a0\\cf.\\d2\\b9k\\84\\ebi\\08\\ad\\bc\\0b\\c0A\\c4P\\b6\\e3P1\\e8\\ce\\e2\\96eU\\9c\\16F\\e6\\b0-:\\e8\\81\\05\\b0\\bf4\\f7\\bc\\10\\1c\\fb\\cc<\\f1\\85\\97B\\9f\\eb\\14\\8d<\\bf\\d7\\17\\88I\\9d\\8b+\\b2:\\83\\d1O\\04\\9e\\a1\\0f\\ad\\08\\9dT\\af\\d1\\82\\c3\\ec2/\\02\\8f\\05!-\\a2\\b7\\e4\\f4o.\\81+\\0b\\9c\\fc\\cb\\fet\\02\\f9\\db\\f4\\f3\\ea\\00\\a8\\ec\\d1\\99t&\\dd\\d64\\d5%\\b1F\\dd\\9c\\aaq\\f5`\\b0\\88\\c8\\e0\\0bYZ%O)f\\f9\\e3.\\fe\\e9\\da\\e5\\18O'b\\f4\\ce\\a4!\\95t\\c7Wd'\\9aL\\fdT}a\\ce\\c3\\ac\\87F\\9c\\fa\\ff\\09\\cay\\97g$t\\ca\\d4!\\83&%\\19\\127d\\19\\e5e\\e0tu\\8e\\dd\\c8\\eft\\c7\\d8!+y\\04QFe`\\03]\\fa\\d8\\f4e\\a4\\9e]#\\da\\d7\\8a\\92\\80\\a4\\dex<\\f1WBm\\cd\\c9/\\d5\\a4\\9e\\ab@\\f4\\cb\\1b\\d7\\a3\\ca\\fc\\eb\\a7\\01\\b2\\9aiNF\\9b\\18N\\ddy\\a7\\aa\\a6R9\\1e\\ef0\\cc\\9b\\bd[\\eeL!m0\\00r\\b0F_\\08\\cf\\c5\\b9\\e0>\\c2\\b3\\0c\\dc\\8ed\\de\\19By\\cfC\\eaC]\\8e\\88\\f7\\ab\\15\\dc?\\c8g \\db\\b8d\\b1G\\1f\\de\\f2\\cb?Y\\9f\\d8F\\90\\dc\\ae/\\22\\f9\\e21\\89\\d9\\9c\\1cL\\d3\\a9JW\\84\\9c\\9f\\ea,<\\ae<\\c3\\1e\\8b\\e5N\\17\\01%\\db4F_\\15\\ea\\05\\0c|\\d9E\\8c\\19\\d0s\\8a\\96\\16\\ddD\\f9\\05\\b7[q\\b0\\e6!6_u\\89\\91su\\ab}\\ae\\d3s\\ec7\\c6\\eaUu\\ef\\ea\\ab\\8b{\\11\\dcm\\1a\\b2j\\c4%\\cf\\aa\\e3\\9fII\\89\\cb7\\9b\\0a\\a7\\01`p\\dc\\b7\\c8\\83\\e1B\\f5\\be\\adb\\94\\ad\\8d\\a1\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_62(instance: &mut Instance) { @@ -8286,16 +10624,28 @@ fn start_module_62(instance: &mut Instance) { // Line 1530 fn c627_l1530_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c627_l1530_action_invoke"); - let result = instance.call("f32.kahan_sum", &[Value::I32(0 as i32), Value::I32(256 as i32)]); - assert_eq!(result, Ok(Some(Value::F32((-21558138000000000000000000000000.0f32))))); + let result = instance.call( + "f32.kahan_sum", + &[Value::I32(0 as i32), Value::I32(256 as i32)], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-21558138000000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 1531 fn c628_l1531_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c628_l1531_action_invoke"); - let result = instance.call("f32.plain_sum", &[Value::I32(0 as i32), Value::I32(256 as i32)]); - assert_eq!(result, Ok(Some(Value::F32((-16487540000000000000000000000000.0f32))))); + let result = instance.call( + "f32.plain_sum", + &[Value::I32(0 as i32), Value::I32(256 as i32)], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-16487540000000000000000000000000.0f32)))) + ); result.map(|_| ()) } @@ -8371,8 +10721,11 @@ fn create_module_63() -> Box { (data (;0;) (i32.const 0) \"\\13\\05\\84B]\\a2,\\c6C\\dbU\\a9\\cd\\daU\\e3s\\fcX\\d6\\ba\\d5\\00\\fd\\835B\\88\\8b\\13]8JG\\0drs\\a1\\1a\\ef\\c4E\\17W\\d8\\c9F\\e0\\8dl\\e17p\\c8\\83[U^Z-s\\1eV\\c8\\e1mi\\14x\\0a\\8aZd:\\09\\c7\\a8\\87\\c5\\f0\\d3]\\e6\\03\\fc\\93\\be&\\ca\\d6\\a9\\91`\\bd\\b0\\ed\\ae\\f70~\\92:o\\a7Y\\8e\\aa}\\bfgX*T\\f8N\\fe\\ed5X\\a6Q\\bfB\\e5Kf'$m\\7fB-(\\92\\18\\ec\\08\\ae\\e7U\\da\\b1\\a6e\\a5rPG\\1b\\b8\\a9T\\d7\\a6\\06[\\0fBX\\83\\8a\\17\\82\\c6\\10C\\a0\\c0.m\\bcZ\\85Sr\\7f\\adD\\bc0I\\f2~H\\f4\\a2q\\d0\\13\\8e\\b3\\de\\99R\\e3Et\\eav\\0e\\1b*\\c8\\ee\\14\\01\\c4P[6<\\ef\\bar\\a2\\a6\\08\\f8{6\\9d\\f9\\ef\\0b\\c7V-\\5c\\f0\\9d]\\de\\fc\\b8\\ad\\0fd\\0e\\97\\152&\\c21\\e6\\05\\1e\\ef\\cb\\17\\1bm\\15\\0bt]\\d3.\\f8k\\86\\b4\\basRS\\99\\a9v E\\c9@\\80k\\14\\ed\\a1\\fa\\80F\\e6&\\d2\\e6\\98\\c4W\\bf\\c4\\1c\\a4\\90z6\\94\\14\\ba\\15\\89n\\e6\\9c7\\8c\\f4\\de\\12\\22]\\a1yPg\\0d=z\\e9\\d4\\aa.\\7f*z0=\\ea]\\12H\\fe\\e1\\18\\cd\\a4W\\a2\\87>\\b6\\9a\\8b\\db\\da\\9dx\\9c\\cf\\8d\\b1O\\90\\b44\\e0\\9d\\f6\\ca\\feL;xm\\0a\\5c\\18\\9fa\\b9\\dd\\b4\\e0\\0fv\\e0\\1bi\\0d^Xsp^\\0e-\\a1}\\ff \\eb\\914\\92\\ac8r*\\1f\\8eq.j\\f1\\af\\c7'p\\d9\\c4W\\f7\\d2<\\1d\\b8\\f0\\f0d\\cf\\dc\\ae\\be\\a3\\cc>\\22}Ni!c\\17\\ed\\03\\02T\\9a\\0fPN\\13Z5\\a1\\22\\a4\\df\\86\\c2ty\\16\\b8ii\\a0R]\\11d\\bd[\\93\\fci\\a0\\f4\\13\\d0\\81Q\\dd\\fa\\0c\\15\\c3z\\c9bz\\a9\\1d\\c9\\e6Z\\b3[\\97\\02\\d0\\c4\\8d4\\19P!\\0a\\bcP\\da<0\\d6:1\\94\\8d:\\fe\\ef\\14W\\9dK\\93\\00\\96$\\0co\\fd\\bc#v\\02l\\ebRr\\80\\11~\\80:\\13\\128\\1d8I\\95@'\\8aD{\\e8\\dcm\\8c\\8c\\8e<\\b5\\b3\\18\\0e\\f6\\08\\1a\\84A5\\ff\\8b\\b8\\93@\\ea\\e1Q\\1d\\89\\a5\\8dBh)\\ea/\\c1zR\\eb\\90]M\\d6\\80\\e3\\d7uH\\ce\\ed\\d3\\01\\1c\\8d[\\a5\\94\\0dx\\cf\\f1\\06\\13/\\98\\02\\a4m.l\\f2\\d5t)\\89L\\f9\\03\\f5\\c7\\18\\adz\\f0h\\f8\\5c\\d6Y\\87n\\d6?\\06\\be\\86 \\e3A\\91\\22\\f3n\\8b\\f0h\\1cW\\a7\\fc\\b0|\\9e\\99\\0b\\96\\1a\\89_\\e6\\0d|\\08Q\\a0\\a2g\\9aG\\00\\93k\\f9(\\f0h\\dbb\\f1\\e0e,S3\\e0\\a7\\ca\\11B0\\f6\\af\\01\\c1e=2\\01o\\ab.\\be\\d3\\8b\\be\\14\\c3\\ff\\ec\\fb\\f0\\f9\\c5\\0c\\05o\\01\\09k\\e341\\0c\\1ff\\a6B\\bc\\1a\\87I\\16\\16\\8c\\b0\\90\\0d4\\8c\\0a\\e1\\09^\\10\\a4kV\\cc\\f0\\c9\\bb\\dc\\b8\\5c\\ce\\f6\\cc\\8du~\\b3\\07\\88\\04/\\b4^\\c9\\e3J#s\\19bl\\9a\\03vD\\86\\9c`\\fc\\dbr\\8f'\\a0\\dd\\b3\\c5\\da\\ff\\f9\\ecj\\b1{\\d3\\cfP7\\c9zx\\0c\\e4:\\b6\\f5\\e6\\f4\\98nB}5s\\8bE\\c0V\\97\\cdm\\ce\\cf\\ad1\\b3\\c3T\\fa\\ef\\d5\\c0\\f4j_T\\e7I>3\\0a08\\fd\\d9\\05\\ff\\a5?WF\\14\\b5\\91\\17\\cak\\98#ze\\b3l\\02\\b4\\ccy]X\\d8\\b3\\d5\\94\\ae\\f4mue\\f7\\92\\bf~GL<\\ee\\db\\ac\\f12]\\fboA\\1c4\\c8\\83O\\c2X\\01\\be\\05>f\\16\\a6\\04m]O\\86\\09'\\82%\\12\\cd:\\cd\\cek\\bc\\ca\\ac(\\9b\\eej%\\86\\9eEp\\c6\\d2\\bd;}B\\e5'\\af\\c7\\1d\\f4\\81\\c8\\b3v\\8a\\a86\\a3\\ae*\\e6\\18\\e16\\22\\ad\\f6%r\\b09\\8b\\01\\9a\\22{\\84\\c3-_r\\a4\\98\\ac\\15p\\e7\\d4\\18\\e2}\\d20|3\\08\\cd\\ca\\c4\\22\\85\\88u\\81\\c6JtX\\8d\\e0\\e8\\ac\\c5\\abuZ\\f4(\\12\\f0\\18ER\\f2\\97\\b2\\93Ao\\8d\\7f\\dbp\\fb\\a3]\\1f\\a7\\8d\\98 +\\22\\9f:\\01\\b5\\8b\\1b\\d2\\cb\\14\\03\\0e\\14\\14\\d2\\19Z\\1f\\ce^\\cd\\81y\\15\\01\\ca\\dest\\8cV \\9fw-%\\16\\f6aQ\\1d\\a4\\8e\\9b\\98\\a5\\c6\\ec\\a8EW\\82Yx\\0d\\90\\b4\\dfQ\\b0\\c3\\82\\94\\cc\\b3S\\09\\15m\\96l:@G\\b7Jz\\05/\\a1\\1e\\8c\\9d\\a0 \\88\\fbR\\b7\\9f\\f3\\f3\\bb_\\e7\\8aa\\a7!\\b1\\ac\\fa\\09\\aa\\a4l\\bc$\\80\\ba*\\e9e\\ffp\\ff\\cc\\fae\\87v\\f3\\c5\\15\\ce\\cb\\e8B1\\00\\0c\\91W\\d9\\e0\\9d5T$\\ad\\a4\\d8\\f9\\08gc\\c8\\cf\\81\\dd\\90\\a2\\d7\\c4\\07J\\e6\\10og\\e7'\\d4#Y\\18\\f2\\a8\\9d_\\d8\\940\\aaT\\86O\\87\\9d\\82\\b5&\\ca\\a6\\96\\bf\\cfU\\f9\\9d7\\01\\19HC\\c5\\94l\\f3t\\97XL<\\9d\\08\\e8\\04\\c2X0v\\e1\\a0\\f8\\ea\\e9\\c5\\ae\\cfx\\9e\\a9\\0c\\ac\\b3DB\\e0\\bc]\\1b\\9cIXJ\\1c\\19I\\c1:\\ea\\f5\\eb;\\81\\a9Kp\\0c\\cc\\9e\\1a\\d3/\\b7R/ ;\\ebdQ\\1d\\a0-\\b2>\\be\\13\\85H\\922.\\db\\5c\\a1\\e7\\8cE\\915\\01\\0a\\93\\c2\\eb\\09\\ce\\f3\\d2\\22$\\d0\\8c\\cc\\1d\\9d8\\c8M\\e3\\82\\ccd\\15\\06-\\e7\\01/\\ab\\bb\\b5\\04L\\92\\1cz\\d6?\\e8_1\\15\\0c\\dc\\e41\\b4\\c4%>*\\aa\\00\\9e\\c8\\e5!z\\7f)\\f1\\c0\\af\\1d^\\e8c9\\ad\\f8~l\\c8\\c5\\7f\\c2\\a8\\97'\\0a\\d9\\f4!j\\ea\\03\\09\\fb\\f7\\96;\\83y_|K0\\9fV5\\de\\b4s\\d4\\95\\f0\\14\\c3t/\\0d\\a3\\1dN\\8d1$\\b3\\1a\\84\\85bZ{<\\149\\17\\e6m\\eb7\\c2\\00X[\\0b\\e3<\\8ab\\e1\\f85KV\\e2\\87`\\8b\\be\\a78\\91wT\\a9Z$%\\90\\9f\\a5Bw\\f3\\5c9\\df\\fft\\07v\\a1\\cd\\1fb\\0b\\81\\81h\\af\\05\\c1\\c0\\7f&\\ee\\c0\\91\\a3j})aE'\\e5W\\88\\dc\\0d\\97\\04\\1a3\\a9D\\8a\\da\\02\\10E?\\8eU\\a6v\\8cM\\e3\\f1\\89\\83\\c8\\d0\\f8\\9bPw\\9fG\\dfL\\9cf\\0d\\aa\\18\\b8_O\\c4\\01\\ce\\dc\\84\\acF\\9ei\\e1vEka\\89\\e4]\\94\\bb\\11\\83\\9fx\\d8\\0a\\d2\\f5~]C\\ea\\bc\\10\\f1:\\c9\\e2d\\fbSe\\d0\\c7\\b4\\a7\\fb\\d4\\05S%\\d0\\cd)\\88\\00V%$}]\\b4\\f3A\\9f\\e9\\b5\\f7\\aed,\\e3\\c9m\\d5\\84:r\\12\\b8z\\d9\\1b\\09\\e88\\da&O\\04\\ce\\03qn\\8aD{\\5c\\81Y\\9c\\d2\\e4\\c3\\baY\\a6\\e5(\\a7\\8f\\9a\\e4\\d5N\\b9\\ca\\7f\\cbu\\b8+C>\\b3\\15F\\b1\\a5\\bc\\9d\\9e8\\15\\f1\\bd\\1b!\\aa\\f1\\82\\00\\95\\fc\\a7wG9\\a73C\\92\\d7R@K\\06\\81\\8a\\a0\\bd\\f1k\\99\\84B[\\e2;\\c5^\\12\\5c(M\\b6\\0eN\\c8\\5c\\e8\\01\\8a\\c5\\e7\\e4\\9dB\\ee]\\9c\\c4\\eb\\ebh\\09'\\92\\95\\9a\\11Ts\\c4\\12\\80\\fb}\\fe\\c5\\08`\\7f6A\\e0\\10\\ba\\d6+l\\f1\\b4\\17\\fe&4\\e3K\\f8\\a8\\e3\\91\\beO*\\fc\\da\\81\\b8\\e7\\fe\\d5&PG\\f3\\1ae2\\81\\e0\\05\\b8O21&\\00JS\\97\\c2\\c3\\0e.\\a1&T\\ab\\05\\8eV/}\\af\\22\\84h\\a5\\8b\\97\\f6\\a4\\fd\\a8\\ccuA\\96\\86\\fd'=)\\86\\8d\\7fL\\d4\\8esA\\f4\\1e\\e2\\ddX'\\97\\ce\\9c\\94\\cfz\\04/\\dc\\ed\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_63(instance: &mut Instance) { @@ -8383,7 +10736,10 @@ fn start_module_63(instance: &mut Instance) { // Line 1581 fn c630_l1581_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c630_l1581_action_invoke"); - let result = instance.call("f64.kahan_sum", &[Value::I32(0 as i32), Value::I32(256 as i32)]); + let result = instance.call( + "f64.kahan_sum", + &[Value::I32(0 as i32), Value::I32(256 as i32)], + ); assert_eq!(result, Ok(Some(Value::F64((4996401743142033000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))))); result.map(|_| ()) } @@ -8391,7 +10747,10 @@ fn c630_l1581_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1582 fn c631_l1582_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c631_l1582_action_invoke"); - let result = instance.call("f64.plain_sum", &[Value::I32(0 as i32), Value::I32(256 as i32)]); + let result = instance.call( + "f64.plain_sum", + &[Value::I32(0 as i32), Value::I32(256 as i32)], + ); assert_eq!(result, Ok(Some(Value::F64((4996401743297957600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))))); result.map(|_| ()) } @@ -8424,8 +10783,11 @@ fn create_module_64() -> Box { (export \"f64.no_fold_neg_sub\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_64(instance: &mut Instance) { @@ -8436,7 +10798,10 @@ fn start_module_64(instance: &mut Instance) { // Line 1594 fn c633_l1594_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c633_l1594_action_invoke"); - let result = instance.call("f32.no_fold_neg_sub", &[Value::F32((-0.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "f32.no_fold_neg_sub", + &[Value::F32((-0.0f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8444,7 +10809,10 @@ fn c633_l1594_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1595 fn c634_l1595_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c634_l1595_action_invoke"); - let result = instance.call("f32.no_fold_neg_sub", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "f32.no_fold_neg_sub", + &[Value::F32((0.0f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8452,7 +10820,10 @@ fn c634_l1595_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1596 fn c635_l1596_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c635_l1596_action_invoke"); - let result = instance.call("f32.no_fold_neg_sub", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_neg_sub", + &[Value::F32((-0.0f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -8460,7 +10831,10 @@ fn c635_l1596_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1597 fn c636_l1597_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c636_l1597_action_invoke"); - let result = instance.call("f32.no_fold_neg_sub", &[Value::F32((0.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_neg_sub", + &[Value::F32((0.0f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8468,7 +10842,10 @@ fn c636_l1597_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1599 fn c637_l1599_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c637_l1599_action_invoke"); - let result = instance.call("f64.no_fold_neg_sub", &[Value::F64((-0.0f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "f64.no_fold_neg_sub", + &[Value::F64((-0.0f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -8476,7 +10853,10 @@ fn c637_l1599_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1600 fn c638_l1600_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c638_l1600_action_invoke"); - let result = instance.call("f64.no_fold_neg_sub", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "f64.no_fold_neg_sub", + &[Value::F64((0.0f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -8484,7 +10864,10 @@ fn c638_l1600_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1601 fn c639_l1601_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c639_l1601_action_invoke"); - let result = instance.call("f64.no_fold_neg_sub", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_neg_sub", + &[Value::F64((-0.0f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -8492,7 +10875,10 @@ fn c639_l1601_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1602 fn c640_l1602_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c640_l1602_action_invoke"); - let result = instance.call("f64.no_fold_neg_sub", &[Value::F64((0.0f64)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_neg_sub", + &[Value::F64((0.0f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -8531,8 +10917,11 @@ fn create_module_65() -> Box { (export \"f64.no_fold_neg_add\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_65(instance: &mut Instance) { @@ -8543,7 +10932,10 @@ fn start_module_65(instance: &mut Instance) { // Line 1614 fn c642_l1614_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c642_l1614_action_invoke"); - let result = instance.call("f32.no_fold_neg_add", &[Value::F32((-0.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "f32.no_fold_neg_add", + &[Value::F32((-0.0f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -8551,7 +10943,10 @@ fn c642_l1614_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1615 fn c643_l1615_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c643_l1615_action_invoke"); - let result = instance.call("f32.no_fold_neg_add", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "f32.no_fold_neg_add", + &[Value::F32((0.0f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8559,7 +10954,10 @@ fn c643_l1615_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1616 fn c644_l1616_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c644_l1616_action_invoke"); - let result = instance.call("f32.no_fold_neg_add", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_neg_add", + &[Value::F32((-0.0f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8567,7 +10965,10 @@ fn c644_l1616_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1617 fn c645_l1617_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c645_l1617_action_invoke"); - let result = instance.call("f32.no_fold_neg_add", &[Value::F32((0.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_neg_add", + &[Value::F32((0.0f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8575,7 +10976,10 @@ fn c645_l1617_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1619 fn c646_l1619_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c646_l1619_action_invoke"); - let result = instance.call("f64.no_fold_neg_add", &[Value::F64((-0.0f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "f64.no_fold_neg_add", + &[Value::F64((-0.0f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -8583,7 +10987,10 @@ fn c646_l1619_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1620 fn c647_l1620_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c647_l1620_action_invoke"); - let result = instance.call("f64.no_fold_neg_add", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "f64.no_fold_neg_add", + &[Value::F64((0.0f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -8591,7 +10998,10 @@ fn c647_l1620_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1621 fn c648_l1621_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c648_l1621_action_invoke"); - let result = instance.call("f64.no_fold_neg_add", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_neg_add", + &[Value::F64((-0.0f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -8599,7 +11009,10 @@ fn c648_l1621_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1622 fn c649_l1622_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c649_l1622_action_invoke"); - let result = instance.call("f64.no_fold_neg_add", &[Value::F64((0.0f64)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_neg_add", + &[Value::F64((0.0f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -8640,8 +11053,11 @@ fn create_module_66() -> Box { (export \"f64.no_fold_add_neg_neg\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_66(instance: &mut Instance) { @@ -8652,7 +11068,10 @@ fn start_module_66(instance: &mut Instance) { // Line 1634 fn c651_l1634_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c651_l1634_action_invoke"); - let result = instance.call("f32.no_fold_add_neg_neg", &[Value::F32((-0.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "f32.no_fold_add_neg_neg", + &[Value::F32((-0.0f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -8660,7 +11079,10 @@ fn c651_l1634_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1635 fn c652_l1635_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c652_l1635_action_invoke"); - let result = instance.call("f32.no_fold_add_neg_neg", &[Value::F32((0.0f32)), Value::F32((-0.0f32))]); + let result = instance.call( + "f32.no_fold_add_neg_neg", + &[Value::F32((0.0f32)), Value::F32((-0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -8668,7 +11090,10 @@ fn c652_l1635_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1636 fn c653_l1636_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c653_l1636_action_invoke"); - let result = instance.call("f32.no_fold_add_neg_neg", &[Value::F32((-0.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_add_neg_neg", + &[Value::F32((-0.0f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -8676,7 +11101,10 @@ fn c653_l1636_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1637 fn c654_l1637_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c654_l1637_action_invoke"); - let result = instance.call("f32.no_fold_add_neg_neg", &[Value::F32((0.0f32)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.no_fold_add_neg_neg", + &[Value::F32((0.0f32)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -8684,7 +11112,10 @@ fn c654_l1637_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1639 fn c655_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c655_l1639_action_invoke"); - let result = instance.call("f64.no_fold_add_neg_neg", &[Value::F64((-0.0f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "f64.no_fold_add_neg_neg", + &[Value::F64((-0.0f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -8692,7 +11123,10 @@ fn c655_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1640 fn c656_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c656_l1640_action_invoke"); - let result = instance.call("f64.no_fold_add_neg_neg", &[Value::F64((0.0f64)), Value::F64((-0.0f64))]); + let result = instance.call( + "f64.no_fold_add_neg_neg", + &[Value::F64((0.0f64)), Value::F64((-0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -8700,7 +11134,10 @@ fn c656_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1641 fn c657_l1641_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c657_l1641_action_invoke"); - let result = instance.call("f64.no_fold_add_neg_neg", &[Value::F64((-0.0f64)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_add_neg_neg", + &[Value::F64((-0.0f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -8708,7 +11145,10 @@ fn c657_l1641_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1642 fn c658_l1642_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c658_l1642_action_invoke"); - let result = instance.call("f64.no_fold_add_neg_neg", &[Value::F64((0.0f64)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.no_fold_add_neg_neg", + &[Value::F64((0.0f64)), Value::F64((0.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } @@ -8747,8 +11187,11 @@ fn create_module_67() -> Box { (export \"f64.no_fold_add_neg\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_67(instance: &mut Instance) { @@ -8774,23 +11217,35 @@ fn c661_l1655_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1656 fn c662_l1656_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c662_l1656_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_add_neg", &[Value::F32(f32::INFINITY)]).unwrap().expect("Missing result in c662_l1656_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c662_l1656_assert_return_canonical_nan" + ); + let result = instance + .call("f32.no_fold_add_neg", &[Value::F32(f32::INFINITY)]) + .unwrap() + .expect("Missing result in c662_l1656_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1657 fn c663_l1657_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c663_l1657_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_add_neg", &[Value::F32(f32::NEG_INFINITY)]).unwrap().expect("Missing result in c663_l1657_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c663_l1657_assert_return_canonical_nan" + ); + let result = instance + .call("f32.no_fold_add_neg", &[Value::F32(f32::NEG_INFINITY)]) + .unwrap() + .expect("Missing result in c663_l1657_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -8812,23 +11267,35 @@ fn c665_l1660_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1661 fn c666_l1661_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c666_l1661_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_add_neg", &[Value::F64(f64::INFINITY)]).unwrap().expect("Missing result in c666_l1661_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c666_l1661_assert_return_canonical_nan" + ); + let result = instance + .call("f64.no_fold_add_neg", &[Value::F64(f64::INFINITY)]) + .unwrap() + .expect("Missing result in c666_l1661_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1662 fn c667_l1662_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c667_l1662_assert_return_canonical_nan"); - let result = instance.call("f64.no_fold_add_neg", &[Value::F64(f64::NEG_INFINITY)]).unwrap().expect("Missing result in c667_l1662_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c667_l1662_assert_return_canonical_nan" + ); + let result = instance + .call("f64.no_fold_add_neg", &[Value::F64(f64::NEG_INFINITY)]) + .unwrap() + .expect("Missing result in c667_l1662_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -8880,8 +11347,11 @@ fn create_module_68() -> Box { (export \"f64.no_fold_6x_via_add\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_68(instance: &mut Instance) { @@ -8892,31 +11362,52 @@ fn start_module_68(instance: &mut Instance) { // Line 1680 fn c669_l1680_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c669_l1680_action_invoke"); - let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((-855513700000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-5133083000000000000000000000000.0f32))))); + let result = instance.call( + "f32.no_fold_6x_via_add", + &[Value::F32((-855513700000000000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-5133083000000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 1681 fn c670_l1681_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c670_l1681_action_invoke"); - let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((-0.00000000000000000000001209506f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000007257036f32))))); + let result = instance.call( + "f32.no_fold_6x_via_add", + &[Value::F32((-0.00000000000000000000001209506f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-0.00000000000000000000007257036f32)))) + ); result.map(|_| ()) } // Line 1682 fn c671_l1682_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c671_l1682_action_invoke"); - let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((0.000000000000000000000006642689f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000039856134f32))))); + let result = instance.call( + "f32.no_fold_6x_via_add", + &[Value::F32((0.000000000000000000000006642689f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.000000000000000000000039856134f32)))) + ); result.map(|_| ()) } // Line 1683 fn c672_l1683_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c672_l1683_action_invoke"); - let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((-0.0000000006147346f32))]); + let result = instance.call( + "f32.no_fold_6x_via_add", + &[Value::F32((-0.0000000006147346f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0000000036884074f32))))); result.map(|_| ()) } @@ -8924,15 +11415,24 @@ fn c672_l1683_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1684 fn c673_l1684_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c673_l1684_action_invoke"); - let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((-1209858100000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-7259148300000000000000000.0f32))))); + let result = instance.call( + "f32.no_fold_6x_via_add", + &[Value::F32((-1209858100000000000000000.0f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-7259148300000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 1686 fn c674_l1686_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c674_l1686_action_invoke"); - let result = instance.call("f64.no_fold_6x_via_add", &[Value::F64((-351704490602771400000.0f64))]); + let result = instance.call( + "f64.no_fold_6x_via_add", + &[Value::F64((-351704490602771400000.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-2110226943616628600000.0f64))))); result.map(|_| ()) } @@ -8964,8 +11464,18 @@ fn c677_l1689_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1690 fn c678_l1690_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c678_l1690_action_invoke"); - let result = instance.call("f64.no_fold_6x_via_add", &[Value::F64((-43116397525195610000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-258698385151173640000000000000000000000000000000000000000000000000000000.0f64))))); + let result = instance.call( + "f64.no_fold_6x_via_add", + &[Value::F64( + (-43116397525195610000000000000000000000000000000000000000000000000000000.0f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (-258698385151173640000000000000000000000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -9007,8 +11517,11 @@ fn create_module_69() -> Box { (export \"f64.no_fold_div_div\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_69(instance: &mut Instance) { @@ -9019,15 +11532,32 @@ fn start_module_69(instance: &mut Instance) { // Line 1703 fn c680_l1703_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c680_l1703_action_invoke"); - let result = instance.call("f32.no_fold_div_div", &[Value::F32((-593847530000000000000000.0f32)), Value::F32((-0.000030265672f32)), Value::F32((-1584.8682f32))]); - assert_eq!(result, Ok(Some(Value::F32((-12380309000000000000000000.0f32))))); + let result = instance.call( + "f32.no_fold_div_div", + &[ + Value::F32((-593847530000000000000000.0f32)), + Value::F32((-0.000030265672f32)), + Value::F32((-1584.8682f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-12380309000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 1704 fn c681_l1704_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c681_l1704_action_invoke"); - let result = instance.call("f32.no_fold_div_div", &[Value::F32((0.0000000000000000000015438962f32)), Value::F32((2533429300000000000000000000000000.0f32)), Value::F32((-0.00000000000000000000000000000000026844783f32))]); + let result = instance.call( + "f32.no_fold_div_div", + &[ + Value::F32((0.0000000000000000000015438962f32)), + Value::F32((2533429300000000000000000000000000.0f32)), + Value::F32((-0.00000000000000000000000000000000026844783f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -9035,7 +11565,14 @@ fn c681_l1704_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1705 fn c682_l1705_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c682_l1705_action_invoke"); - let result = instance.call("f32.no_fold_div_div", &[Value::F32((13417423000000.0f32)), Value::F32((0.000000000000000000000000000000029339205f32)), Value::F32((76386374000000000000000000000000.0f32))]); + let result = instance.call( + "f32.no_fold_div_div", + &[ + Value::F32((13417423000000.0f32)), + Value::F32((0.000000000000000000000000000000029339205f32)), + Value::F32((76386374000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9043,16 +11580,40 @@ fn c682_l1705_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1706 fn c683_l1706_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c683_l1706_action_invoke"); - let result = instance.call("f32.no_fold_div_div", &[Value::F32((-0.00010776529f32)), Value::F32((-34220943000000000000000000000000000000.0f32)), Value::F32((-0.00000000000016562324f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000019011327f32))))); + let result = instance.call( + "f32.no_fold_div_div", + &[ + Value::F32((-0.00010776529f32)), + Value::F32((-34220943000000000000000000000000000000.0f32)), + Value::F32((-0.00000000000016562324f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000019011327f32) + ))) + ); result.map(|_| ()) } // Line 1707 fn c684_l1707_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c684_l1707_action_invoke"); - let result = instance.call("f32.no_fold_div_div", &[Value::F32((130582500000000.0f32)), Value::F32((96245350000000000.0f32)), Value::F32((-41461545000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000032723f32))))); + let result = instance.call( + "f32.no_fold_div_div", + &[ + Value::F32((130582500000000.0f32)), + Value::F32((96245350000000000.0f32)), + Value::F32((-41461545000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000032723f32) + ))) + ); result.map(|_| ()) } @@ -9092,7 +11653,12 @@ fn c688_l1712_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c689_l1713_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c689_l1713_action_invoke"); let result = instance.call("f64.no_fold_div_div", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009525735602663874f64)), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000050233948816631796f64)), Value::F64((-0.0000000000000000000000000000000000000000028304570228221077f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000006699534674970116f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.00000000000000000000000000000000000000000000006699534674970116f64) + ))) + ); result.map(|_| ()) } @@ -9138,8 +11704,11 @@ fn create_module_70() -> Box { (export \"f64.no_fold_mul_divs\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_70(instance: &mut Instance) { @@ -9150,15 +11719,36 @@ fn start_module_70(instance: &mut Instance) { // Line 1727 fn c691_l1727_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c691_l1727_action_invoke"); - let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((-0.0000000000000000000000000000000027234733f32)), Value::F32((0.0000000000000000000000000003897843f32)), Value::F32((0.000000000000000000000000004847123f32)), Value::F32((-25.357775f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000013355855f32))))); + let result = instance.call( + "f32.no_fold_mul_divs", + &[ + Value::F32((-0.0000000000000000000000000000000027234733f32)), + Value::F32((0.0000000000000000000000000003897843f32)), + Value::F32((0.000000000000000000000000004847123f32)), + Value::F32((-25.357775f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.0000000000000000000000000000000013355855f32) + ))) + ); result.map(|_| ()) } // Line 1728 fn c692_l1728_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c692_l1728_action_invoke"); - let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((-5372844000000000000000000000000.0f32)), Value::F32((38340910.0f32)), Value::F32((0.000014973162f32)), Value::F32((0.19213825f32))]); + let result = instance.call( + "f32.no_fold_mul_divs", + &[ + Value::F32((-5372844000000000000000000000000.0f32)), + Value::F32((38340910.0f32)), + Value::F32((0.000014973162f32)), + Value::F32((0.19213825f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-10920475000000000000.0f32))))); result.map(|_| ()) } @@ -9166,7 +11756,15 @@ fn c692_l1728_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1729 fn c693_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c693_l1729_action_invoke"); - let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((-16085042000.0f32)), Value::F32((-1092920200000.0f32)), Value::F32((-869606000.0f32)), Value::F32((-1201.206f32))]); + let result = instance.call( + "f32.no_fold_mul_divs", + &[ + Value::F32((-16085042000.0f32)), + Value::F32((-1092920200000.0f32)), + Value::F32((-869606000.0f32)), + Value::F32((-1201.206f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((10654.639f32))))); result.map(|_| ()) } @@ -9174,7 +11772,15 @@ fn c693_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1730 fn c694_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c694_l1730_action_invoke"); - let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((-1271223140000000000000000000000000.0f32)), Value::F32((0.00000000010768114f32)), Value::F32((0.000018576271f32)), Value::F32((492686200000000000000000.0f32))]); + let result = instance.call( + "f32.no_fold_mul_divs", + &[ + Value::F32((-1271223140000000000000000000000000.0f32)), + Value::F32((0.00000000010768114f32)), + Value::F32((0.000018576271f32)), + Value::F32((492686200000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9182,7 +11788,15 @@ fn c694_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1731 fn c695_l1731_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c695_l1731_action_invoke"); - let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((0.00000000000000013783864f32)), Value::F32((-0.000000000000000000065046285f32)), Value::F32((0.00000000000000000000000000068167684f32)), Value::F32((0.000000000022892627f32))]); + let result = instance.call( + "f32.no_fold_mul_divs", + &[ + Value::F32((0.00000000000000013783864f32)), + Value::F32((-0.000000000000000000065046285f32)), + Value::F32((0.00000000000000000000000000068167684f32)), + Value::F32((0.000000000022892627f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.000000000000063100295f32))))); result.map(|_| ()) } @@ -9269,8 +11883,11 @@ fn create_module_71() -> Box { (export \"f64.no_fold_add_divs\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_71(instance: &mut Instance) { @@ -9281,31 +11898,74 @@ fn start_module_71(instance: &mut Instance) { // Line 1749 fn c702_l1749_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c702_l1749_action_invoke"); - let result = instance.call("f32.no_fold_add_divs", &[Value::F32((377.3689f32)), Value::F32((-0.040118184f32)), Value::F32((-136292990000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000000000000000027685121f32))))); + let result = instance.call( + "f32.no_fold_add_divs", + &[ + Value::F32((377.3689f32)), + Value::F32((-0.040118184f32)), + Value::F32((-136292990000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.0000000000000000000000000000000000027685121f32) + ))) + ); result.map(|_| ()) } // Line 1750 fn c703_l1750_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c703_l1750_action_invoke"); - let result = instance.call("f32.no_fold_add_divs", &[Value::F32((-0.00000000000000000018234023f32)), Value::F32((-0.0000000000000033970288f32)), Value::F32((-170996700000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000019867115f32))))); + let result = instance.call( + "f32.no_fold_add_divs", + &[ + Value::F32((-0.00000000000000000018234023f32)), + Value::F32((-0.0000000000000033970288f32)), + Value::F32((-170996700000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000019867115f32) + ))) + ); result.map(|_| ()) } // Line 1751 fn c704_l1751_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c704_l1751_action_invoke"); - let result = instance.call("f32.no_fold_add_divs", &[Value::F32((-0.000000000000019672638f32)), Value::F32((0.00000000000000000006414099f32)), Value::F32((-541989070000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000036296997f32))))); + let result = instance.call( + "f32.no_fold_add_divs", + &[ + Value::F32((-0.000000000000019672638f32)), + Value::F32((0.00000000000000000006414099f32)), + Value::F32((-541989070000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000036296997f32) + ))) + ); result.map(|_| ()) } // Line 1752 fn c705_l1752_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c705_l1752_action_invoke"); - let result = instance.call("f32.no_fold_add_divs", &[Value::F32((-0.0000000000000000000000000000004038506f32)), Value::F32((0.000000000000000000000000000003848228f32)), Value::F32((-345237200000000000000000000.0f32))]); + let result = instance.call( + "f32.no_fold_add_divs", + &[ + Value::F32((-0.0000000000000000000000000000004038506f32)), + Value::F32((0.000000000000000000000000000003848228f32)), + Value::F32((-345237200000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -9313,8 +11973,20 @@ fn c705_l1752_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1753 fn c706_l1753_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c706_l1753_action_invoke"); - let result = instance.call("f32.no_fold_add_divs", &[Value::F32((0.0010934415f32)), Value::F32((0.20703124f32)), Value::F32((0.00000000000000000000000000000000000013509784f32))]); - assert_eq!(result, Ok(Some(Value::F32((1540547700000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.no_fold_add_divs", + &[ + Value::F32((0.0010934415f32)), + Value::F32((0.20703124f32)), + Value::F32((0.00000000000000000000000000000000000013509784f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (1540547700000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -9394,8 +12066,11 @@ fn create_module_72() -> Box { (export \"f64.no_fold_sqrt_square\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_72(instance: &mut Instance) { @@ -9406,31 +12081,52 @@ fn start_module_72(instance: &mut Instance) { // Line 1771 fn c713_l1771_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c713_l1771_action_invoke"); - let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((-0.00000000000000000001846f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000001846001f32))))); + let result = instance.call( + "f32.no_fold_sqrt_square", + &[Value::F32((-0.00000000000000000001846f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.00000000000000000001846001f32)))) + ); result.map(|_| ()) } // Line 1772 fn c714_l1772_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c714_l1772_action_invoke"); - let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((-0.00000000000000000000017907473f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000017952678f32))))); + let result = instance.call( + "f32.no_fold_sqrt_square", + &[Value::F32((-0.00000000000000000000017907473f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.00000000000000000000017952678f32)))) + ); result.map(|_| ()) } // Line 1773 fn c715_l1773_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c715_l1773_action_invoke"); - let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((-0.00000000000000000000079120785f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000791442f32))))); + let result = instance.call( + "f32.no_fold_sqrt_square", + &[Value::F32((-0.00000000000000000000079120785f32))], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.000000000000000000000791442f32)))) + ); result.map(|_| ()) } // Line 1774 fn c716_l1774_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c716_l1774_action_invoke"); - let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((0.000000000000000000000000018012938f32))]); + let result = instance.call( + "f32.no_fold_sqrt_square", + &[Value::F32((0.000000000000000000000000018012938f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -9438,7 +12134,10 @@ fn c716_l1774_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1775 fn c717_l1775_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c717_l1775_action_invoke"); - let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((610501970000000000000000000000000.0f32))]); + let result = instance.call( + "f32.no_fold_sqrt_square", + &[Value::F32((610501970000000000000000000000000.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -9521,8 +12220,11 @@ fn create_module_73() -> Box { (export \"f64.no_fold_mul_sqrts\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_73(instance: &mut Instance) { @@ -9532,27 +12234,54 @@ fn start_module_73(instance: &mut Instance) { // Line 1793 fn c724_l1793_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c724_l1793_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((0.000000000000000000000000000000000000043885047f32)), Value::F32((-0.00000000000000000000000011867334f32))]).unwrap().expect("Missing result in c724_l1793_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c724_l1793_assert_return_canonical_nan" + ); + let result = instance + .call( + "f32.no_fold_mul_sqrts", + &[ + Value::F32((0.000000000000000000000000000000000000043885047f32)), + Value::F32((-0.00000000000000000000000011867334f32)), + ], + ) + .unwrap() + .expect("Missing result in c724_l1793_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1794 fn c725_l1794_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c725_l1794_action_invoke"); - let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((0.00000000000000000000000000025365908f32)), Value::F32((0.00000000041320675f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000032374932f32))))); + let result = instance.call( + "f32.no_fold_mul_sqrts", + &[ + Value::F32((0.00000000000000000000000000025365908f32)), + Value::F32((0.00000000041320675f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.00000000000000000032374932f32)))) + ); result.map(|_| ()) } // Line 1795 fn c726_l1795_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c726_l1795_action_invoke"); - let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((0.0000000000000000000000000042144832f32)), Value::F32((97.249115f32))]); + let result = instance.call( + "f32.no_fold_mul_sqrts", + &[ + Value::F32((0.0000000000000000000000000042144832f32)), + Value::F32((97.249115f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000000000064019905f32))))); result.map(|_| ()) } @@ -9560,7 +12289,13 @@ fn c726_l1795_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1796 fn c727_l1796_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c727_l1796_action_invoke"); - let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((3724076300000000000000000000000.0f32)), Value::F32((0.002944908f32))]); + let result = instance.call( + "f32.no_fold_mul_sqrts", + &[ + Value::F32((3724076300000000000000000000000.0f32)), + Value::F32((0.002944908f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((104723750000000.0f32))))); result.map(|_| ()) } @@ -9568,19 +12303,28 @@ fn c727_l1796_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1797 fn c728_l1797_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c728_l1797_action_invoke"); - let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((0.00000000000000001866056f32)), Value::F32((0.002111261f32))]); + let result = instance.call( + "f32.no_fold_mul_sqrts", + &[ + Value::F32((0.00000000000000001866056f32)), + Value::F32((0.002111261f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000000019848755f32))))); result.map(|_| ()) } // Line 1799 fn c729_l1799_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c729_l1799_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c729_l1799_assert_return_canonical_nan" + ); let result = instance.call("f64.no_fold_mul_sqrts", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012742064369772862f64)), Value::F64((-0.006829962938197246f64))]).unwrap().expect("Missing result in c729_l1799_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -9654,8 +12398,11 @@ fn create_module_74() -> Box { (export \"f64.no_fold_div_sqrts\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_74(instance: &mut Instance) { @@ -9665,19 +12412,34 @@ fn start_module_74(instance: &mut Instance) { // Line 1815 fn c735_l1815_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c735_l1815_assert_return_canonical_nan"); - let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((-58545012.0f32)), Value::F32((-0.000000000000000006443773f32))]).unwrap().expect("Missing result in c735_l1815_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c735_l1815_assert_return_canonical_nan" + ); + let result = instance + .call( + "f32.no_fold_div_sqrts", + &[ + Value::F32((-58545012.0f32)), + Value::F32((-0.000000000000000006443773f32)), + ], + ) + .unwrap() + .expect("Missing result in c735_l1815_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 1816 fn c736_l1816_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c736_l1816_action_invoke"); - let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((7407384000.0f32)), Value::F32((209778930.0f32))]); + let result = instance.call( + "f32.no_fold_div_sqrts", + &[Value::F32((7407384000.0f32)), Value::F32((209778930.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((5.9422584f32))))); result.map(|_| ()) } @@ -9685,15 +12447,30 @@ fn c736_l1816_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1817 fn c737_l1817_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c737_l1817_action_invoke"); - let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((0.0000000000000000000000000000000000013764126f32)), Value::F32((54692.9f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000050165927f32))))); + let result = instance.call( + "f32.no_fold_div_sqrts", + &[ + Value::F32((0.0000000000000000000000000000000000013764126f32)), + Value::F32((54692.9f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.0000000000000000000050165927f32)))) + ); result.map(|_| ()) } // Line 1818 fn c738_l1818_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c738_l1818_action_invoke"); - let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((979288960000000000.0f32)), Value::F32((0.0000000012643552f32))]); + let result = instance.call( + "f32.no_fold_div_sqrts", + &[ + Value::F32((979288960000000000.0f32)), + Value::F32((0.0000000012643552f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((27830490000000.0f32))))); result.map(|_| ()) } @@ -9701,19 +12478,28 @@ fn c738_l1818_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1819 fn c739_l1819_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c739_l1819_action_invoke"); - let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((0.00000000000000000000000000000000029141283f32)), Value::F32((0.00000000000000000000000000000017928174f32))]); + let result = instance.call( + "f32.no_fold_div_sqrts", + &[ + Value::F32((0.00000000000000000000000000000000029141283f32)), + Value::F32((0.00000000000000000000000000000017928174f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.04031682f32))))); result.map(|_| ()) } // Line 1821 fn c740_l1821_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c740_l1821_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c740_l1821_assert_return_canonical_nan" + ); let result = instance.call("f64.no_fold_div_sqrts", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012206137319883022f64)), Value::F64((-0.000000000000000000000000000000000000000000000000000000008209583449676083f64))]).unwrap().expect("Missing result in c740_l1821_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } @@ -9789,8 +12575,11 @@ fn create_module_75() -> Box { (export \"f64.no_fold_mul_sqrt_div\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_75(instance: &mut Instance) { @@ -9801,7 +12590,13 @@ fn start_module_75(instance: &mut Instance) { // Line 1837 fn c746_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c746_l1837_action_invoke"); - let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((-4728556800000000000000000.0f32)), Value::F32((8677282000000000000000000000.0f32))]); + let result = instance.call( + "f32.no_fold_mul_sqrt_div", + &[ + Value::F32((-4728556800000000000000000.0f32)), + Value::F32((8677282000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY)))); result.map(|_| ()) } @@ -9809,7 +12604,13 @@ fn c746_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1838 fn c747_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c747_l1838_action_invoke"); - let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((-0.0000000000000000000000000000000000011776882f32)), Value::F32((0.000000000000000000000000000009805153f32))]); + let result = instance.call( + "f32.no_fold_mul_sqrt_div", + &[ + Value::F32((-0.0000000000000000000000000000000000011776882f32)), + Value::F32((0.000000000000000000000000000009805153f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -9817,15 +12618,30 @@ fn c747_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1839 fn c748_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c748_l1839_action_invoke"); - let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((816717060.0f32)), Value::F32((0.000000000000000000000000000000000000003323171f32))]); - assert_eq!(result, Ok(Some(Value::F32((14167568000000000000000000000.0f32))))); + let result = instance.call( + "f32.no_fold_mul_sqrt_div", + &[ + Value::F32((816717060.0f32)), + Value::F32((0.000000000000000000000000000000000000003323171f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((14167568000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 1840 fn c749_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c749_l1840_action_invoke"); - let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((-11932267000000.0f32)), Value::F32((8637067000000000000000000000000000.0f32))]); + let result = instance.call( + "f32.no_fold_mul_sqrt_div", + &[ + Value::F32((-11932267000000.0f32)), + Value::F32((8637067000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.00012839255f32))))); result.map(|_| ()) } @@ -9833,7 +12649,10 @@ fn c749_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1841 fn c750_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c750_l1841_action_invoke"); - let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((-401.0235f32)), Value::F32((134.33022f32))]); + let result = instance.call( + "f32.no_fold_mul_sqrt_div", + &[Value::F32((-401.0235f32)), Value::F32((134.33022f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-34.600548f32))))); result.map(|_| ()) } @@ -9916,8 +12735,11 @@ fn create_module_76() -> Box { (export \"f64.no_flush_intermediate_subnormal\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_76(instance: &mut Instance) { @@ -9928,8 +12750,20 @@ fn start_module_76(instance: &mut Instance) { // Line 1860 fn c757_l1860_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c757_l1860_action_invoke"); - let result = instance.call("f32.no_flush_intermediate_subnormal", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.00000011920929f32)), Value::F32((8388608.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "f32.no_flush_intermediate_subnormal", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.00000011920929f32)), + Value::F32((8388608.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } @@ -10006,8 +12840,11 @@ fn create_module_77() -> Box { (export \"recoding_demote\" (func 6))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_77(instance: &mut Instance) { @@ -10018,7 +12855,10 @@ fn start_module_77(instance: &mut Instance) { // Line 1889 fn c760_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c760_l1889_action_invoke"); - let result = instance.call("f32.recoding_eq", &[Value::F32(f32::NEG_INFINITY), Value::F32((3.0f32))]); + let result = instance.call( + "f32.recoding_eq", + &[Value::F32(f32::NEG_INFINITY), Value::F32((3.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10026,7 +12866,10 @@ fn c760_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1890 fn c761_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c761_l1890_action_invoke"); - let result = instance.call("f32.recoding_le", &[Value::F32(f32::NEG_INFINITY), Value::F32((3.0f32))]); + let result = instance.call( + "f32.recoding_le", + &[Value::F32(f32::NEG_INFINITY), Value::F32((3.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10034,7 +12877,10 @@ fn c761_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1891 fn c762_l1891_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c762_l1891_action_invoke"); - let result = instance.call("f32.recoding_lt", &[Value::F32(f32::NEG_INFINITY), Value::F32((3.0f32))]); + let result = instance.call( + "f32.recoding_lt", + &[Value::F32(f32::NEG_INFINITY), Value::F32((3.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10042,7 +12888,10 @@ fn c762_l1891_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1893 fn c763_l1893_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c763_l1893_action_invoke"); - let result = instance.call("f32.recoding_eq", &[Value::F32((0.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "f32.recoding_eq", + &[Value::F32((0.0f32)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10050,7 +12899,10 @@ fn c763_l1893_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1894 fn c764_l1894_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c764_l1894_action_invoke"); - let result = instance.call("f32.recoding_le", &[Value::F32((0.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "f32.recoding_le", + &[Value::F32((0.0f32)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10058,7 +12910,10 @@ fn c764_l1894_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1895 fn c765_l1895_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c765_l1895_action_invoke"); - let result = instance.call("f32.recoding_lt", &[Value::F32((0.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "f32.recoding_lt", + &[Value::F32((0.0f32)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10066,7 +12921,10 @@ fn c765_l1895_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1897 fn c766_l1897_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c766_l1897_action_invoke"); - let result = instance.call("f64.recoding_eq", &[Value::F64(f64::NEG_INFINITY), Value::F64((3.0f64))]); + let result = instance.call( + "f64.recoding_eq", + &[Value::F64(f64::NEG_INFINITY), Value::F64((3.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10074,7 +12932,10 @@ fn c766_l1897_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1898 fn c767_l1898_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c767_l1898_action_invoke"); - let result = instance.call("f64.recoding_le", &[Value::F64(f64::NEG_INFINITY), Value::F64((3.0f64))]); + let result = instance.call( + "f64.recoding_le", + &[Value::F64(f64::NEG_INFINITY), Value::F64((3.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10082,7 +12943,10 @@ fn c767_l1898_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1899 fn c768_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c768_l1899_action_invoke"); - let result = instance.call("f64.recoding_lt", &[Value::F64(f64::NEG_INFINITY), Value::F64((3.0f64))]); + let result = instance.call( + "f64.recoding_lt", + &[Value::F64(f64::NEG_INFINITY), Value::F64((3.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10090,7 +12954,10 @@ fn c768_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1901 fn c769_l1901_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c769_l1901_action_invoke"); - let result = instance.call("f64.recoding_eq", &[Value::F64((0.0f64)), Value::F64((1.0f64))]); + let result = instance.call( + "f64.recoding_eq", + &[Value::F64((0.0f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10098,7 +12965,10 @@ fn c769_l1901_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1902 fn c770_l1902_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c770_l1902_action_invoke"); - let result = instance.call("f64.recoding_le", &[Value::F64((0.0f64)), Value::F64((1.0f64))]); + let result = instance.call( + "f64.recoding_le", + &[Value::F64((0.0f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10106,7 +12976,10 @@ fn c770_l1902_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1903 fn c771_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c771_l1903_action_invoke"); - let result = instance.call("f64.recoding_lt", &[Value::F64((0.0f64)), Value::F64((1.0f64))]); + let result = instance.call( + "f64.recoding_lt", + &[Value::F64((0.0f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10114,8 +12987,19 @@ fn c771_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1905 fn c772_l1905_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c772_l1905_action_invoke"); - let result = instance.call("recoding_demote", &[Value::F64((0.00000000000000000000000000000000000000023860049081905093f64)), Value::F32((1221.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000002913312f32))))); + let result = instance.call( + "recoding_demote", + &[ + Value::F64((0.00000000000000000000000000000000000000023860049081905093f64)), + Value::F32((1221.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.0000000000000000000000000000000000002913312f32) + ))) + ); result.map(|_| ()) } @@ -10160,8 +13044,11 @@ fn create_module_78() -> Box { (export \"f64.no_extended_precision_div\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_78(instance: &mut Instance) { @@ -10172,7 +13059,14 @@ fn start_module_78(instance: &mut Instance) { // Line 1918 fn c774_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c774_l1918_action_invoke"); - let result = instance.call("f32.no_extended_precision_div", &[Value::F32((3.0f32)), Value::F32((7.0f32)), Value::F32((0.42857143f32))]); + let result = instance.call( + "f32.no_extended_precision_div", + &[ + Value::F32((3.0f32)), + Value::F32((7.0f32)), + Value::F32((0.42857143f32)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10180,7 +13074,14 @@ fn c774_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1919 fn c775_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c775_l1919_action_invoke"); - let result = instance.call("f64.no_extended_precision_div", &[Value::F64((3.0f64)), Value::F64((7.0f64)), Value::F64((0.42857142857142855f64))]); + let result = instance.call( + "f64.no_extended_precision_div", + &[ + Value::F64((3.0f64)), + Value::F64((7.0f64)), + Value::F64((0.42857142857142855f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10219,8 +13120,11 @@ fn create_module_79() -> Box { (export \"f64.no_distribute_exact\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_79(instance: &mut Instance) { @@ -10352,8 +13256,11 @@ fn create_module_80() -> Box { (export \"f64.xkcd_better_sqrt_5\" (func 9))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_80(instance: &mut Instance) { @@ -10372,7 +13279,15 @@ fn c780_l1972_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1973 fn c781_l1973_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c781_l1973_action_invoke"); - let result = instance.call("f32.xkcd_sqrt_2", &[Value::F32((3.0f32)), Value::F32((5.0f32)), Value::F32((3.1415927f32)), Value::F32((7.0f32))]); + let result = instance.call( + "f32.xkcd_sqrt_2", + &[ + Value::F32((3.0f32)), + Value::F32((5.0f32)), + Value::F32((3.1415927f32)), + Value::F32((7.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.4142201f32))))); result.map(|_| ()) } @@ -10388,7 +13303,14 @@ fn c782_l1974_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1975 fn c783_l1975_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c783_l1975_action_invoke"); - let result = instance.call("f32.xkcd_sqrt_3", &[Value::F32((2.0f32)), Value::F32((2.7182817f32)), Value::F32((3.1415927f32))]); + let result = instance.call( + "f32.xkcd_sqrt_3", + &[ + Value::F32((2.0f32)), + Value::F32((2.7182817f32)), + Value::F32((3.1415927f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.7305119f32))))); result.map(|_| ()) } @@ -10404,7 +13326,14 @@ fn c784_l1976_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1977 fn c785_l1977_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c785_l1977_action_invoke"); - let result = instance.call("f32.xkcd_sqrt_5", &[Value::F32((2.0f32)), Value::F32((2.7182817f32)), Value::F32((3.0f32))]); + let result = instance.call( + "f32.xkcd_sqrt_5", + &[ + Value::F32((2.0f32)), + Value::F32((2.7182817f32)), + Value::F32((3.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((2.2357588f32))))); result.map(|_| ()) } @@ -10412,7 +13341,15 @@ fn c785_l1977_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1978 fn c786_l1978_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c786_l1978_action_invoke"); - let result = instance.call("f32.xkcd_better_sqrt_5", &[Value::F32((13.0f32)), Value::F32((4.0f32)), Value::F32((3.1415927f32)), Value::F32((24.0f32))]); + let result = instance.call( + "f32.xkcd_better_sqrt_5", + &[ + Value::F32((13.0f32)), + Value::F32((4.0f32)), + Value::F32((3.1415927f32)), + Value::F32((24.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((2.236068f32))))); result.map(|_| ()) } @@ -10428,7 +13365,15 @@ fn c787_l1980_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1981 fn c788_l1981_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c788_l1981_action_invoke"); - let result = instance.call("f64.xkcd_sqrt_2", &[Value::F64((3.0f64)), Value::F64((5.0f64)), Value::F64((3.141592653589793f64)), Value::F64((7.0f64))]); + let result = instance.call( + "f64.xkcd_sqrt_2", + &[ + Value::F64((3.0f64)), + Value::F64((5.0f64)), + Value::F64((3.141592653589793f64)), + Value::F64((7.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.4142200580539208f64))))); result.map(|_| ()) } @@ -10444,7 +13389,14 @@ fn c789_l1982_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1983 fn c790_l1983_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c790_l1983_action_invoke"); - let result = instance.call("f64.xkcd_sqrt_3", &[Value::F64((2.0f64)), Value::F64((2.718281828459045f64)), Value::F64((3.141592653589793f64))]); + let result = instance.call( + "f64.xkcd_sqrt_3", + &[ + Value::F64((2.0f64)), + Value::F64((2.718281828459045f64)), + Value::F64((3.141592653589793f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.7305119588645301f64))))); result.map(|_| ()) } @@ -10460,7 +13412,14 @@ fn c791_l1984_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1985 fn c792_l1985_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c792_l1985_action_invoke"); - let result = instance.call("f64.xkcd_sqrt_5", &[Value::F64((2.0f64)), Value::F64((2.718281828459045f64)), Value::F64((3.0f64))]); + let result = instance.call( + "f64.xkcd_sqrt_5", + &[ + Value::F64((2.0f64)), + Value::F64((2.718281828459045f64)), + Value::F64((3.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((2.2357588823428847f64))))); result.map(|_| ()) } @@ -10468,7 +13427,15 @@ fn c792_l1985_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 1986 fn c793_l1986_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c793_l1986_action_invoke"); - let result = instance.call("f64.xkcd_better_sqrt_5", &[Value::F64((13.0f64)), Value::F64((4.0f64)), Value::F64((3.141592653589793f64)), Value::F64((24.0f64))]); + let result = instance.call( + "f64.xkcd_better_sqrt_5", + &[ + Value::F64((13.0f64)), + Value::F64((4.0f64)), + Value::F64((3.141592653589793f64)), + Value::F64((24.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((2.2360678094452893f64))))); result.map(|_| ()) } @@ -10567,8 +13534,11 @@ fn create_module_81() -> Box { (export \"f64.compute_radix\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_81(instance: &mut Instance) { @@ -10579,7 +13549,10 @@ fn start_module_81(instance: &mut Instance) { // Line 2069 fn c795_l2069_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c795_l2069_action_invoke"); - let result = instance.call("f32.compute_radix", &[Value::F32((1.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "f32.compute_radix", + &[Value::F32((1.0f32)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((2.0f32))))); result.map(|_| ()) } @@ -10587,7 +13560,10 @@ fn c795_l2069_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2070 fn c796_l2070_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c796_l2070_action_invoke"); - let result = instance.call("f64.compute_radix", &[Value::F64((1.0f64)), Value::F64((1.0f64))]); + let result = instance.call( + "f64.compute_radix", + &[Value::F64((1.0f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((2.0f64))))); result.map(|_| ()) } @@ -10626,8 +13602,11 @@ fn create_module_82() -> Box { (export \"f64.no_fold_sub1_mul_add\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_82(instance: &mut Instance) { @@ -10638,7 +13617,10 @@ fn start_module_82(instance: &mut Instance) { // Line 2083 fn c798_l2083_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c798_l2083_action_invoke"); - let result = instance.call("f32.no_fold_sub1_mul_add", &[Value::F32((0.00000000023283064f32)), Value::F32((1.0f32))]); + let result = instance.call( + "f32.no_fold_sub1_mul_add", + &[Value::F32((0.00000000023283064f32)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -10646,7 +13628,13 @@ fn c798_l2083_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2084 fn c799_l2084_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c799_l2084_action_invoke"); - let result = instance.call("f64.no_fold_sub1_mul_add", &[Value::F64((0.00000000000000000005421010862427522f64)), Value::F64((1.0f64))]); + let result = instance.call( + "f64.no_fold_sub1_mul_add", + &[ + Value::F64((0.00000000000000000005421010862427522f64)), + Value::F64((1.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -10703,8 +13691,11 @@ fn create_module_83() -> Box { (export \"f64.no_fold_add_ge_monotonicity\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_83(instance: &mut Instance) { @@ -10715,7 +13706,14 @@ fn start_module_83(instance: &mut Instance) { // Line 2103 fn c801_l2103_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c801_l2103_action_invoke"); - let result = instance.call("f32.no_fold_add_le_monotonicity", &[Value::F32((0.0f32)), Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_fold_add_le_monotonicity", + &[ + Value::F32((0.0f32)), + Value::F32((0.0f32)), + Value::F32(f32::from_bits(2143289344)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10723,7 +13721,14 @@ fn c801_l2103_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2104 fn c802_l2104_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c802_l2104_action_invoke"); - let result = instance.call("f32.no_fold_add_le_monotonicity", &[Value::F32(f32::INFINITY), Value::F32(f32::NEG_INFINITY), Value::F32(f32::INFINITY)]); + let result = instance.call( + "f32.no_fold_add_le_monotonicity", + &[ + Value::F32(f32::INFINITY), + Value::F32(f32::NEG_INFINITY), + Value::F32(f32::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10731,7 +13736,14 @@ fn c802_l2104_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2105 fn c803_l2105_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c803_l2105_action_invoke"); - let result = instance.call("f64.no_fold_add_le_monotonicity", &[Value::F64((0.0f64)), Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_fold_add_le_monotonicity", + &[ + Value::F64((0.0f64)), + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10739,7 +13751,14 @@ fn c803_l2105_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2106 fn c804_l2106_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c804_l2106_action_invoke"); - let result = instance.call("f64.no_fold_add_le_monotonicity", &[Value::F64(f64::INFINITY), Value::F64(f64::NEG_INFINITY), Value::F64(f64::INFINITY)]); + let result = instance.call( + "f64.no_fold_add_le_monotonicity", + &[ + Value::F64(f64::INFINITY), + Value::F64(f64::NEG_INFINITY), + Value::F64(f64::INFINITY), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -10810,8 +13829,11 @@ fn create_module_84() -> Box { (export \"f64.not_ge\" (func 7))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_84(instance: &mut Instance) { @@ -10822,7 +13844,10 @@ fn start_module_84(instance: &mut Instance) { // Line 2136 fn c806_l2136_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c806_l2136_action_invoke"); - let result = instance.call("f32.not_lt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.not_lt", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10830,7 +13855,10 @@ fn c806_l2136_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2137 fn c807_l2137_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c807_l2137_action_invoke"); - let result = instance.call("f32.not_le", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.not_le", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10838,7 +13866,10 @@ fn c807_l2137_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2138 fn c808_l2138_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c808_l2138_action_invoke"); - let result = instance.call("f32.not_gt", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.not_gt", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10846,7 +13877,10 @@ fn c808_l2138_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2139 fn c809_l2139_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c809_l2139_action_invoke"); - let result = instance.call("f32.not_ge", &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))]); + let result = instance.call( + "f32.not_ge", + &[Value::F32(f32::from_bits(2143289344)), Value::F32((0.0f32))], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10854,7 +13888,13 @@ fn c809_l2139_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2140 fn c810_l2140_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c810_l2140_action_invoke"); - let result = instance.call("f64.not_lt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.not_lt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10862,7 +13902,13 @@ fn c810_l2140_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2141 fn c811_l2141_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c811_l2141_action_invoke"); - let result = instance.call("f64.not_le", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.not_le", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10870,7 +13916,13 @@ fn c811_l2141_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2142 fn c812_l2142_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c812_l2142_action_invoke"); - let result = instance.call("f64.not_gt", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.not_gt", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10878,7 +13930,13 @@ fn c812_l2142_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2143 fn c813_l2143_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c813_l2143_action_invoke"); - let result = instance.call("f64.not_ge", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((0.0f64))]); + let result = instance.call( + "f64.not_ge", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((0.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -10927,8 +13985,11 @@ fn create_module_85() -> Box { (export \"f64.epsilon\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_85(instance: &mut Instance) { @@ -10948,7 +14009,10 @@ fn c815_l2157_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c816_l2158_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c816_l2158_action_invoke"); let result = instance.call("f64.epsilon", &[]); - assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((0.0000000000000002220446049250313f64)))) + ); result.map(|_| ()) } @@ -11004,8 +14068,11 @@ fn create_module_86() -> Box { (export \"f64.epsilon\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_86(instance: &mut Instance) { @@ -11025,7 +14092,10 @@ fn c818_l2212_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c819_l2213_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c819_l2213_action_invoke"); let result = instance.call("f64.epsilon", &[]); - assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((0.0000000000000002220446049250313f64)))) + ); result.map(|_| ()) } @@ -11117,8 +14187,11 @@ fn create_module_87() -> Box { (export \"f64.no_trichotomy_ge\" (func 7))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_87(instance: &mut Instance) { @@ -11129,7 +14202,10 @@ fn start_module_87(instance: &mut Instance) { // Line 2238 fn c821_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c821_l2238_action_invoke"); - let result = instance.call("f32.no_trichotomy_lt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_trichotomy_lt", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11137,7 +14213,10 @@ fn c821_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2239 fn c822_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c822_l2239_action_invoke"); - let result = instance.call("f32.no_trichotomy_le", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_trichotomy_le", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11145,7 +14224,10 @@ fn c822_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2240 fn c823_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c823_l2240_action_invoke"); - let result = instance.call("f32.no_trichotomy_gt", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_trichotomy_gt", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11153,7 +14235,10 @@ fn c823_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2241 fn c824_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c824_l2241_action_invoke"); - let result = instance.call("f32.no_trichotomy_ge", &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.no_trichotomy_ge", + &[Value::F32((0.0f32)), Value::F32(f32::from_bits(2143289344))], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11161,7 +14246,13 @@ fn c824_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2242 fn c825_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c825_l2242_action_invoke"); - let result = instance.call("f64.no_trichotomy_lt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_trichotomy_lt", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11169,7 +14260,13 @@ fn c825_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2243 fn c826_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c826_l2243_action_invoke"); - let result = instance.call("f64.no_trichotomy_le", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_trichotomy_le", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11177,7 +14274,13 @@ fn c826_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2244 fn c827_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c827_l2244_action_invoke"); - let result = instance.call("f64.no_trichotomy_gt", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_trichotomy_gt", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11185,7 +14288,13 @@ fn c827_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2245 fn c828_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c828_l2245_action_invoke"); - let result = instance.call("f64.no_trichotomy_ge", &[Value::F64((0.0f64)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.no_trichotomy_ge", + &[ + Value::F64((0.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -11383,8 +14492,11 @@ fn create_module_88() -> Box { (export \"no_fold_promote_demote\" (func 18))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_88(instance: &mut Instance) { @@ -11395,7 +14507,10 @@ fn start_module_88(instance: &mut Instance) { // Line 2329 fn c830_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c830_l2329_action_invoke"); - let result = instance.call("f32.arithmetic_nan_bitpattern", &[Value::I32(2139107856 as i32), Value::I32(2139107856 as i32)]); + let result = instance.call( + "f32.arithmetic_nan_bitpattern", + &[Value::I32(2139107856 as i32), Value::I32(2139107856 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); result.map(|_| ()) } @@ -11403,7 +14518,10 @@ fn c830_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2330 fn c831_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c831_l2330_action_invoke"); - let result = instance.call("f32.canonical_nan_bitpattern", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "f32.canonical_nan_bitpattern", + &[Value::I32(0 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); result.map(|_| ()) } @@ -11411,7 +14529,10 @@ fn c831_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2331 fn c832_l2331_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c832_l2331_action_invoke"); - let result = instance.call("f32.canonical_nan_bitpattern", &[Value::I32(2143289344 as i32), Value::I32(2143289344 as i32)]); + let result = instance.call( + "f32.canonical_nan_bitpattern", + &[Value::I32(2143289344 as i32), Value::I32(2143289344 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); result.map(|_| ()) } @@ -11419,7 +14540,10 @@ fn c832_l2331_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2332 fn c833_l2332_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c833_l2332_action_invoke"); - let result = instance.call("f32.canonical_nan_bitpattern", &[Value::I32(-4194304 as i32), Value::I32(2143289344 as i32)]); + let result = instance.call( + "f32.canonical_nan_bitpattern", + &[Value::I32(-4194304 as i32), Value::I32(2143289344 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); result.map(|_| ()) } @@ -11427,7 +14551,10 @@ fn c833_l2332_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2333 fn c834_l2333_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c834_l2333_action_invoke"); - let result = instance.call("f32.canonical_nan_bitpattern", &[Value::I32(2143289344 as i32), Value::I32(-4194304 as i32)]); + let result = instance.call( + "f32.canonical_nan_bitpattern", + &[Value::I32(2143289344 as i32), Value::I32(-4194304 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); result.map(|_| ()) } @@ -11435,7 +14562,10 @@ fn c834_l2333_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2334 fn c835_l2334_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c835_l2334_action_invoke"); - let result = instance.call("f32.canonical_nan_bitpattern", &[Value::I32(-4194304 as i32), Value::I32(-4194304 as i32)]); + let result = instance.call( + "f32.canonical_nan_bitpattern", + &[Value::I32(-4194304 as i32), Value::I32(-4194304 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); result.map(|_| ()) } @@ -11443,7 +14573,10 @@ fn c835_l2334_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2335 fn c836_l2335_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c836_l2335_action_invoke"); - let result = instance.call("f32.nonarithmetic_nan_bitpattern", &[Value::I32(2143302160 as i32)]); + let result = instance.call( + "f32.nonarithmetic_nan_bitpattern", + &[Value::I32(2143302160 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-4181488 as i32)))); result.map(|_| ()) } @@ -11451,7 +14584,10 @@ fn c836_l2335_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2336 fn c837_l2336_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c837_l2336_action_invoke"); - let result = instance.call("f32.nonarithmetic_nan_bitpattern", &[Value::I32(-4181488 as i32)]); + let result = instance.call( + "f32.nonarithmetic_nan_bitpattern", + &[Value::I32(-4181488 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2143302160 as i32)))); result.map(|_| ()) } @@ -11459,7 +14595,10 @@ fn c837_l2336_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2337 fn c838_l2337_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c838_l2337_action_invoke"); - let result = instance.call("f32.nonarithmetic_nan_bitpattern", &[Value::I32(2139107856 as i32)]); + let result = instance.call( + "f32.nonarithmetic_nan_bitpattern", + &[Value::I32(2139107856 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-8375792 as i32)))); result.map(|_| ()) } @@ -11467,7 +14606,10 @@ fn c838_l2337_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2338 fn c839_l2338_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c839_l2338_action_invoke"); - let result = instance.call("f32.nonarithmetic_nan_bitpattern", &[Value::I32(-8375792 as i32)]); + let result = instance.call( + "f32.nonarithmetic_nan_bitpattern", + &[Value::I32(-8375792 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2139107856 as i32)))); result.map(|_| ()) } @@ -11475,7 +14617,13 @@ fn c839_l2338_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2339 fn c840_l2339_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c840_l2339_action_invoke"); - let result = instance.call("f64.arithmetic_nan_bitpattern", &[Value::I64(9218868437227418128 as i64), Value::I64(9218868437227418128 as i64)]); + let result = instance.call( + "f64.arithmetic_nan_bitpattern", + &[ + Value::I64(9218868437227418128 as i64), + Value::I64(9218868437227418128 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); result.map(|_| ()) } @@ -11483,7 +14631,10 @@ fn c840_l2339_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2340 fn c841_l2340_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c841_l2340_action_invoke"); - let result = instance.call("f64.canonical_nan_bitpattern", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "f64.canonical_nan_bitpattern", + &[Value::I64(0 as i64), Value::I64(0 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); result.map(|_| ()) } @@ -11491,7 +14642,13 @@ fn c841_l2340_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2341 fn c842_l2341_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c842_l2341_action_invoke"); - let result = instance.call("f64.canonical_nan_bitpattern", &[Value::I64(9221120237041090560 as i64), Value::I64(9221120237041090560 as i64)]); + let result = instance.call( + "f64.canonical_nan_bitpattern", + &[ + Value::I64(9221120237041090560 as i64), + Value::I64(9221120237041090560 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); result.map(|_| ()) } @@ -11499,7 +14656,13 @@ fn c842_l2341_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2342 fn c843_l2342_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c843_l2342_action_invoke"); - let result = instance.call("f64.canonical_nan_bitpattern", &[Value::I64(-2251799813685248 as i64), Value::I64(9221120237041090560 as i64)]); + let result = instance.call( + "f64.canonical_nan_bitpattern", + &[ + Value::I64(-2251799813685248 as i64), + Value::I64(9221120237041090560 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); result.map(|_| ()) } @@ -11507,7 +14670,13 @@ fn c843_l2342_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2343 fn c844_l2343_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c844_l2343_action_invoke"); - let result = instance.call("f64.canonical_nan_bitpattern", &[Value::I64(9221120237041090560 as i64), Value::I64(-2251799813685248 as i64)]); + let result = instance.call( + "f64.canonical_nan_bitpattern", + &[ + Value::I64(9221120237041090560 as i64), + Value::I64(-2251799813685248 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); result.map(|_| ()) } @@ -11515,7 +14684,13 @@ fn c844_l2343_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2344 fn c845_l2344_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c845_l2344_action_invoke"); - let result = instance.call("f64.canonical_nan_bitpattern", &[Value::I64(-2251799813685248 as i64), Value::I64(-2251799813685248 as i64)]); + let result = instance.call( + "f64.canonical_nan_bitpattern", + &[ + Value::I64(-2251799813685248 as i64), + Value::I64(-2251799813685248 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); result.map(|_| ()) } @@ -11523,7 +14698,10 @@ fn c845_l2344_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2345 fn c846_l2345_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c846_l2345_action_invoke"); - let result = instance.call("f64.nonarithmetic_nan_bitpattern", &[Value::I64(9221120237041103376 as i64)]); + let result = instance.call( + "f64.nonarithmetic_nan_bitpattern", + &[Value::I64(9221120237041103376 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(-2251799813672432 as i64)))); result.map(|_| ()) } @@ -11531,7 +14709,10 @@ fn c846_l2345_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2346 fn c847_l2346_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c847_l2346_action_invoke"); - let result = instance.call("f64.nonarithmetic_nan_bitpattern", &[Value::I64(-2251799813672432 as i64)]); + let result = instance.call( + "f64.nonarithmetic_nan_bitpattern", + &[Value::I64(-2251799813672432 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(9221120237041103376 as i64)))); result.map(|_| ()) } @@ -11539,7 +14720,10 @@ fn c847_l2346_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2347 fn c848_l2347_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c848_l2347_action_invoke"); - let result = instance.call("f64.nonarithmetic_nan_bitpattern", &[Value::I64(9218868437227418128 as i64)]); + let result = instance.call( + "f64.nonarithmetic_nan_bitpattern", + &[Value::I64(9218868437227418128 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(-4503599627357680 as i64)))); result.map(|_| ()) } @@ -11547,7 +14731,10 @@ fn c848_l2347_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2348 fn c849_l2348_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c849_l2348_action_invoke"); - let result = instance.call("f64.nonarithmetic_nan_bitpattern", &[Value::I64(-4503599627357680 as i64)]); + let result = instance.call( + "f64.nonarithmetic_nan_bitpattern", + &[Value::I64(-4503599627357680 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(9218868437227418128 as i64)))); result.map(|_| ()) } @@ -11603,7 +14790,10 @@ fn c855_l2354_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2355 fn c856_l2355_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c856_l2355_action_invoke"); - let result = instance.call("f64.no_fold_sub_zero", &[Value::I64(9219994337134247936 as i64)]); + let result = instance.call( + "f64.no_fold_sub_zero", + &[Value::I64(9219994337134247936 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); result.map(|_| ()) } @@ -11611,7 +14801,10 @@ fn c856_l2355_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2356 fn c857_l2356_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c857_l2356_action_invoke"); - let result = instance.call("f64.no_fold_neg0_sub", &[Value::I64(9219994337134247936 as i64)]); + let result = instance.call( + "f64.no_fold_neg0_sub", + &[Value::I64(9219994337134247936 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); result.map(|_| ()) } @@ -11619,7 +14812,10 @@ fn c857_l2356_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2357 fn c858_l2357_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c858_l2357_action_invoke"); - let result = instance.call("f64.no_fold_mul_one", &[Value::I64(9219994337134247936 as i64)]); + let result = instance.call( + "f64.no_fold_mul_one", + &[Value::I64(9219994337134247936 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); result.map(|_| ()) } @@ -11627,7 +14823,10 @@ fn c858_l2357_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2358 fn c859_l2358_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c859_l2358_action_invoke"); - let result = instance.call("f64.no_fold_neg1_mul", &[Value::I64(9219994337134247936 as i64)]); + let result = instance.call( + "f64.no_fold_neg1_mul", + &[Value::I64(9219994337134247936 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); result.map(|_| ()) } @@ -11635,7 +14834,10 @@ fn c859_l2358_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2359 fn c860_l2359_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c860_l2359_action_invoke"); - let result = instance.call("f64.no_fold_div_one", &[Value::I64(9219994337134247936 as i64)]); + let result = instance.call( + "f64.no_fold_div_one", + &[Value::I64(9219994337134247936 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); result.map(|_| ()) } @@ -11643,7 +14845,10 @@ fn c860_l2359_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2360 fn c861_l2360_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c861_l2360_action_invoke"); - let result = instance.call("f64.no_fold_div_neg1", &[Value::I64(9219994337134247936 as i64)]); + let result = instance.call( + "f64.no_fold_div_neg1", + &[Value::I64(9219994337134247936 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); result.map(|_| ()) } @@ -11736,8 +14941,11 @@ fn create_module_89() -> Box { (export \"with_binary_sum_collapse\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_89(instance: &mut Instance) { @@ -11748,7 +14956,19 @@ fn start_module_89(instance: &mut Instance) { // Line 2389 fn c864_l2389_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c864_l2389_action_invoke"); - let result = instance.call("dot_product_example", &[Value::F64((32000000.0f64)), Value::F64((1.0f64)), Value::F64((-1.0f64)), Value::F64((80000000.0f64)), Value::F64((40000000.0f64)), Value::F64((1.0f64)), Value::F64((-1.0f64)), Value::F64((-16000000.0f64))]); + let result = instance.call( + "dot_product_example", + &[ + Value::F64((32000000.0f64)), + Value::F64((1.0f64)), + Value::F64((-1.0f64)), + Value::F64((80000000.0f64)), + Value::F64((40000000.0f64)), + Value::F64((1.0f64)), + Value::F64((-1.0f64)), + Value::F64((-16000000.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((2.0f64))))); result.map(|_| ()) } @@ -11756,7 +14976,19 @@ fn c864_l2389_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2393 fn c865_l2393_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c865_l2393_action_invoke"); - let result = instance.call("with_binary_sum_collapse", &[Value::F64((32000000.0f64)), Value::F64((1.0f64)), Value::F64((-1.0f64)), Value::F64((80000000.0f64)), Value::F64((40000000.0f64)), Value::F64((1.0f64)), Value::F64((-1.0f64)), Value::F64((-16000000.0f64))]); + let result = instance.call( + "with_binary_sum_collapse", + &[ + Value::F64((32000000.0f64)), + Value::F64((1.0f64)), + Value::F64((-1.0f64)), + Value::F64((80000000.0f64)), + Value::F64((40000000.0f64)), + Value::F64((1.0f64)), + Value::F64((-1.0f64)), + Value::F64((-16000000.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((2.0f64))))); result.map(|_| ()) } @@ -11797,8 +15029,11 @@ fn create_module_90() -> Box { (export \"f64.contract2fma\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_90(instance: &mut Instance) { @@ -11809,7 +15044,10 @@ fn start_module_90(instance: &mut Instance) { // Line 2411 fn c867_l2411_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c867_l2411_action_invoke"); - let result = instance.call("f32.contract2fma", &[Value::F32((1.0f32)), Value::F32((1.0f32))]); + let result = instance.call( + "f32.contract2fma", + &[Value::F32((1.0f32)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11817,7 +15055,10 @@ fn c867_l2411_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2412 fn c868_l2412_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c868_l2412_action_invoke"); - let result = instance.call("f32.contract2fma", &[Value::F32((1.1f32)), Value::F32((1.1f32))]); + let result = instance.call( + "f32.contract2fma", + &[Value::F32((1.1f32)), Value::F32((1.1f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11825,7 +15066,10 @@ fn c868_l2412_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2413 fn c869_l2413_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c869_l2413_action_invoke"); - let result = instance.call("f32.contract2fma", &[Value::F32((1.1999999f32)), Value::F32((1.1999999f32))]); + let result = instance.call( + "f32.contract2fma", + &[Value::F32((1.1999999f32)), Value::F32((1.1999999f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -11833,7 +15077,10 @@ fn c869_l2413_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2414 fn c870_l2414_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c870_l2414_action_invoke"); - let result = instance.call("f64.contract2fma", &[Value::F64((1.0f64)), Value::F64((1.0f64))]); + let result = instance.call( + "f64.contract2fma", + &[Value::F64((1.0f64)), Value::F64((1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -11841,7 +15088,10 @@ fn c870_l2414_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2415 fn c871_l2415_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c871_l2415_action_invoke"); - let result = instance.call("f64.contract2fma", &[Value::F64((1.1f64)), Value::F64((1.1f64))]); + let result = instance.call( + "f64.contract2fma", + &[Value::F64((1.1f64)), Value::F64((1.1f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -11849,7 +15099,10 @@ fn c871_l2415_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2416 fn c872_l2416_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c872_l2416_action_invoke"); - let result = instance.call("f64.contract2fma", &[Value::F64((1.2f64)), Value::F64((1.2f64))]); + let result = instance.call( + "f64.contract2fma", + &[Value::F64((1.2f64)), Value::F64((1.2f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0f64))))); result.map(|_| ()) } @@ -11888,8 +15141,11 @@ fn create_module_91() -> Box { (export \"f64.division_by_small_number\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_91(instance: &mut Instance) { @@ -11900,7 +15156,14 @@ fn start_module_91(instance: &mut Instance) { // Line 2430 fn c874_l2430_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c874_l2430_action_invoke"); - let result = instance.call("f32.division_by_small_number", &[Value::F32((112000000.0f32)), Value::F32((100000.0f32)), Value::F32((0.0009f32))]); + let result = instance.call( + "f32.division_by_small_number", + &[ + Value::F32((112000000.0f32)), + Value::F32((100000.0f32)), + Value::F32((0.0009f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((888888.0f32))))); result.map(|_| ()) } @@ -11908,7 +15171,14 @@ fn c874_l2430_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2431 fn c875_l2431_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c875_l2431_action_invoke"); - let result = instance.call("f64.division_by_small_number", &[Value::F64((112000000.0f64)), Value::F64((100000.0f64)), Value::F64((0.0009f64))]); + let result = instance.call( + "f64.division_by_small_number", + &[ + Value::F64((112000000.0f64)), + Value::F64((100000.0f64)), + Value::F64((0.0009f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((888888.8888888806f64))))); result.map(|_| ()) } @@ -11945,8 +15215,11 @@ fn create_module_92() -> Box { (export \"f64.golden_ratio\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_92(instance: &mut Instance) { @@ -11957,7 +15230,14 @@ fn start_module_92(instance: &mut Instance) { // Line 2443 fn c877_l2443_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c877_l2443_action_invoke"); - let result = instance.call("f32.golden_ratio", &[Value::F32((0.5f32)), Value::F32((1.0f32)), Value::F32((5.0f32))]); + let result = instance.call( + "f32.golden_ratio", + &[ + Value::F32((0.5f32)), + Value::F32((1.0f32)), + Value::F32((5.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.618034f32))))); result.map(|_| ()) } @@ -11965,7 +15245,14 @@ fn c877_l2443_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2444 fn c878_l2444_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c878_l2444_action_invoke"); - let result = instance.call("f64.golden_ratio", &[Value::F64((0.5f64)), Value::F64((1.0f64)), Value::F64((5.0f64))]); + let result = instance.call( + "f64.golden_ratio", + &[ + Value::F64((0.5f64)), + Value::F64((1.0f64)), + Value::F64((5.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.618033988749895f64))))); result.map(|_| ()) } @@ -12010,8 +15297,11 @@ fn create_module_93() -> Box { (export \"f64.silver_means\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_93(instance: &mut Instance) { @@ -12147,8 +15437,11 @@ fn create_module_94() -> Box { (export \"point_four\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_94(instance: &mut Instance) { @@ -12240,8 +15533,11 @@ fn create_module_95() -> Box { (export \"tau\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_95(instance: &mut Instance) { @@ -12301,8 +15597,11 @@ fn create_module_96() -> Box { (export \"f64.no_fold_conditional_inc\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_96(instance: &mut Instance) { @@ -12313,7 +15612,10 @@ fn start_module_96(instance: &mut Instance) { // Line 2569 fn c898_l2569_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c898_l2569_action_invoke"); - let result = instance.call("f32.no_fold_conditional_inc", &[Value::F32((-0.0f32)), Value::F32((-1.0f32))]); + let result = instance.call( + "f32.no_fold_conditional_inc", + &[Value::F32((-0.0f32)), Value::F32((-1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0f32))))); result.map(|_| ()) } @@ -12321,7 +15623,10 @@ fn c898_l2569_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 2570 fn c899_l2570_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c899_l2570_action_invoke"); - let result = instance.call("f64.no_fold_conditional_inc", &[Value::F64((-0.0f64)), Value::F64((-1.0f64))]); + let result = instance.call( + "f64.no_fold_conditional_inc", + &[Value::F64((-0.0f64)), Value::F64((-1.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((-0.0f64))))); result.map(|_| ()) } diff --git a/lib/runtime/tests/spectests/float_literals.rs b/lib/runtime/tests/spectests/float_literals.rs index aed211b86..1643055fe 100644 --- a/lib/runtime/tests/spectests/float_literals.rs +++ b/lib/runtime/tests/spectests/float_literals.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -335,8 +331,11 @@ fn create_module_1() -> Box { (export \"f64-hex-sep5\" (func 81))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -876,7 +875,10 @@ fn c66_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c67_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c67_l173_action_invoke"); let result = instance.call("f32-dec-sep5", &[]); - assert_eq!(result, Ok(Some(Value::F32((12200012000000000000000000000.0f32))))); + assert_eq!( + result, + Ok(Some(Value::F32((12200012000000000000000000000.0f32)))) + ); result.map(|_| ()) } @@ -956,7 +958,10 @@ fn c76_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c77_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c77_l184_action_invoke"); let result = instance.call("f64-dec-sep5", &[]); - assert_eq!(result, Ok(Some(Value::F64((12200011354000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((12200011354000000000000000000.0f64)))) + ); result.map(|_| ()) } @@ -1098,8 +1103,11 @@ fn create_module_2() -> Box { (export \"4294967249\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -1118,609 +1126,1065 @@ fn c84_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 204 #[test] fn c85_l204_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 208 #[test] fn c86_l208_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 43, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 43, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 212 #[test] fn c87_l212_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 45, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 216 #[test] fn c88_l216_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 57, 57, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 57, 57, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 220 #[test] fn c89_l220_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 95, 95, 48, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 49, 95, 95, 48, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 224 #[test] fn c90_l224_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 95, 49, 46, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 95, 49, 46, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 228 #[test] fn c91_l228_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 49, 46, 48, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 232 #[test] fn c92_l232_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 95, 46, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 49, 95, 46, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 236 #[test] fn c93_l236_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 46, 95, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 49, 46, 95, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 240 #[test] fn c94_l240_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 95, 49, 101, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 95, 49, 101, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 244 #[test] fn c95_l244_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 101, 49, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 49, 101, 49, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 248 #[test] fn c96_l248_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 95, 101, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 49, 95, 101, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 252 #[test] fn c97_l252_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 101, 95, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 49, 101, 95, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 256 #[test] fn c98_l256_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 95, 49, 46, 48, 101, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 95, 49, 46, 48, 101, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 260 #[test] fn c99_l260_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 49, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 49, 46, 48, 101, 49, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 264 #[test] fn c100_l264_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 95, 101, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 49, 46, 48, 95, 101, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 268 #[test] fn c101_l268_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 95, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 49, 46, 48, 101, 95, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 272 #[test] fn c102_l272_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 43, 95, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 49, 46, 48, 101, 43, 95, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 276 #[test] fn c103_l276_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 95, 43, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 49, 46, 48, 101, 95, 43, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 280 #[test] fn c104_l280_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 95, 48, 120, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 95, 48, 120, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 284 #[test] fn c105_l284_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 95, 120, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 95, 120, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 288 #[test] fn c106_l288_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 292 #[test] fn c107_l292_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 48, 48, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 48, 48, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 296 #[test] fn c108_l296_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 102, 102, 95, 95, 102, 102, 102, 102, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 102, 102, 95, 95, 102, 102, 102, 102, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 300 #[test] fn c109_l300_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 46, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 95, 49, 46, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 304 #[test] fn c110_l304_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 46, 48, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 308 #[test] fn c111_l308_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 95, 46, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 95, 46, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 312 #[test] fn c112_l312_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 95, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 46, 95, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 316 #[test] fn c113_l316_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 112, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 95, 49, 112, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 320 #[test] fn c114_l320_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 112, 49, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 112, 49, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 324 #[test] fn c115_l324_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 95, 112, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 95, 112, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 328 #[test] fn c116_l328_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 112, 95, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 112, 95, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 332 #[test] fn c117_l332_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 46, 48, 112, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 95, 49, 46, 48, 112, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 336 #[test] fn c118_l336_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 49, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 46, 48, 112, 49, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 340 #[test] fn c119_l340_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 95, 112, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 46, 48, 95, 112, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 344 #[test] fn c120_l344_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 95, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 46, 48, 112, 95, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 348 #[test] fn c121_l348_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 43, 95, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 46, 48, 112, 43, 95, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 352 #[test] fn c122_l352_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 95, 43, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 46, 48, 112, 95, 43, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 357 #[test] fn c123_l357_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 361 #[test] fn c124_l361_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 43, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 43, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 365 #[test] fn c125_l365_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 45, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 369 #[test] fn c126_l369_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 57, 57, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 57, 57, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 373 #[test] fn c127_l373_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 95, 95, 48, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 49, 95, 95, 48, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 377 #[test] fn c128_l377_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 95, 49, 46, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 95, 49, 46, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 381 #[test] fn c129_l381_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 49, 46, 48, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 385 #[test] fn c130_l385_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 95, 46, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 49, 95, 46, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 389 #[test] fn c131_l389_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 46, 95, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 49, 46, 95, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 393 #[test] fn c132_l393_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 95, 49, 101, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 95, 49, 101, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 397 #[test] fn c133_l397_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 101, 49, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 49, 101, 49, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 401 #[test] fn c134_l401_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 95, 101, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 49, 95, 101, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 405 #[test] fn c135_l405_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 101, 95, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 49, 101, 95, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 409 #[test] fn c136_l409_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 95, 49, 46, 48, 101, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 95, 49, 46, 48, 101, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 413 #[test] fn c137_l413_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 49, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 49, 46, 48, 101, 49, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 417 #[test] fn c138_l417_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 95, 101, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 49, 46, 48, 95, 101, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 421 #[test] fn c139_l421_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 95, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 49, 46, 48, 101, 95, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 425 #[test] fn c140_l425_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 43, 95, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 49, 46, 48, 101, 43, 95, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 429 #[test] fn c141_l429_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 95, 43, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 49, 46, 48, 101, 95, 43, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 433 #[test] fn c142_l433_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 95, 48, 120, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 95, 48, 120, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 437 #[test] fn c143_l437_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 95, 120, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 95, 120, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 441 #[test] fn c144_l441_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 445 #[test] fn c145_l445_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 48, 48, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 48, 48, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 449 #[test] fn c146_l449_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 102, 102, 95, 95, 102, 102, 102, 102, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 102, 102, 95, 95, 102, 102, 102, 102, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 453 #[test] fn c147_l453_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 46, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 95, 49, 46, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 457 #[test] fn c148_l457_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 46, 48, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 461 #[test] fn c149_l461_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 95, 46, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 95, 46, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 465 #[test] fn c150_l465_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 95, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 46, 95, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 469 #[test] fn c151_l469_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 112, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 95, 49, 112, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 473 #[test] fn c152_l473_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 112, 49, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 112, 49, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 477 #[test] fn c153_l477_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 95, 112, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 95, 112, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 481 #[test] fn c154_l481_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 112, 95, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 112, 95, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 485 #[test] fn c155_l485_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 46, 48, 112, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 95, 49, 46, 48, 112, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 489 #[test] fn c156_l489_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 49, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 46, 48, 112, 49, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 493 #[test] fn c157_l493_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 95, 112, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 46, 48, 95, 112, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 497 #[test] fn c158_l497_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 95, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 46, 48, 112, 95, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 501 #[test] fn c159_l501_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 43, 95, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 46, 48, 112, 43, 95, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 505 #[test] fn c160_l505_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 95, 43, 49, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 49, 46, 48, 112, 95, 43, 49, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } #[test] diff --git a/lib/runtime/tests/spectests/float_memory.rs b/lib/runtime/tests/spectests/float_memory.rs index 46084f769..5a62a83c4 100644 --- a/lib/runtime/tests/spectests/float_memory.rs +++ b/lib/runtime/tests/spectests/float_memory.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 5 fn create_module_1() -> Box { @@ -51,8 +47,11 @@ fn create_module_1() -> Box { (data (;0;) (i32.const 0) \"\\00\\00\\a0\\7f\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -73,12 +72,15 @@ fn c2_l16_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2_l16_action_invoke"); let result = instance.call("f32.load", &[]); let expected = f32::from_bits(2141192192); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -86,7 +88,7 @@ fn c2_l16_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c3_l17_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c3_l17_action_invoke"); let result = instance.call("reset", &[]); - + result.map(|_| ()) } @@ -110,7 +112,7 @@ fn c5_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c6_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c6_l20_action_invoke"); let result = instance.call("f32.store", &[]); - + result.map(|_| ()) } @@ -127,12 +129,15 @@ fn c8_l22_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c8_l22_action_invoke"); let result = instance.call("f32.load", &[]); let expected = f32::from_bits(2141192192); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -140,7 +145,7 @@ fn c8_l22_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c9_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c9_l23_action_invoke"); let result = instance.call("reset", &[]); - + result.map(|_| ()) } @@ -164,7 +169,7 @@ fn c11_l25_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c12_l26_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c12_l26_action_invoke"); let result = instance.call("i32.store", &[]); - + result.map(|_| ()) } @@ -181,12 +186,15 @@ fn c14_l28_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c14_l28_action_invoke"); let result = instance.call("f32.load", &[]); let expected = f32::from_bits(2141192192); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -244,8 +252,11 @@ fn create_module_2() -> Box { (data (;0;) (i32.const 0) \"\\00\\00\\00\\00\\00\\00\\f4\\7f\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -266,12 +277,15 @@ fn c17_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c17_l41_action_invoke"); let result = instance.call("f64.load", &[]); let expected = f64::from_bits(9219994337134247936); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -279,7 +293,7 @@ fn c17_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c18_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c18_l42_action_invoke"); let result = instance.call("reset", &[]); - + result.map(|_| ()) } @@ -303,7 +317,7 @@ fn c20_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c21_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c21_l45_action_invoke"); let result = instance.call("f64.store", &[]); - + result.map(|_| ()) } @@ -320,12 +334,15 @@ fn c23_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c23_l47_action_invoke"); let result = instance.call("f64.load", &[]); let expected = f64::from_bits(9219994337134247936); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -333,7 +350,7 @@ fn c23_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c24_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c24_l48_action_invoke"); let result = instance.call("reset", &[]); - + result.map(|_| ()) } @@ -357,7 +374,7 @@ fn c26_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c27_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c27_l51_action_invoke"); let result = instance.call("i64.store", &[]); - + result.map(|_| ()) } @@ -374,12 +391,15 @@ fn c29_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c29_l53_action_invoke"); let result = instance.call("f64.load", &[]); let expected = f64::from_bits(9219994337134247936); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -437,8 +457,11 @@ fn create_module_3() -> Box { (data (;0;) (i32.const 0) \"\\00\\00\\00\\a0\\7f\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -459,12 +482,15 @@ fn c32_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c32_l68_action_invoke"); let result = instance.call("f32.load", &[]); let expected = f32::from_bits(2141192192); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -472,7 +498,7 @@ fn c32_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c33_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c33_l69_action_invoke"); let result = instance.call("reset", &[]); - + result.map(|_| ()) } @@ -496,7 +522,7 @@ fn c35_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c36_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c36_l72_action_invoke"); let result = instance.call("f32.store", &[]); - + result.map(|_| ()) } @@ -513,12 +539,15 @@ fn c38_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c38_l74_action_invoke"); let result = instance.call("f32.load", &[]); let expected = f32::from_bits(2141192192); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -526,7 +555,7 @@ fn c38_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c39_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c39_l75_action_invoke"); let result = instance.call("reset", &[]); - + result.map(|_| ()) } @@ -550,7 +579,7 @@ fn c41_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c42_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c42_l78_action_invoke"); let result = instance.call("i32.store", &[]); - + result.map(|_| ()) } @@ -567,12 +596,15 @@ fn c44_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c44_l80_action_invoke"); let result = instance.call("f32.load", &[]); let expected = f32::from_bits(2141192192); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -630,8 +662,11 @@ fn create_module_4() -> Box { (data (;0;) (i32.const 0) \"\\00\\00\\00\\00\\00\\00\\00\\f4\\7f\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { @@ -652,12 +687,15 @@ fn c47_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c47_l93_action_invoke"); let result = instance.call("f64.load", &[]); let expected = f64::from_bits(9219994337134247936); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -665,7 +703,7 @@ fn c47_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c48_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c48_l94_action_invoke"); let result = instance.call("reset", &[]); - + result.map(|_| ()) } @@ -689,7 +727,7 @@ fn c50_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c51_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c51_l97_action_invoke"); let result = instance.call("f64.store", &[]); - + result.map(|_| ()) } @@ -706,12 +744,15 @@ fn c53_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c53_l99_action_invoke"); let result = instance.call("f64.load", &[]); let expected = f64::from_bits(9219994337134247936); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -719,7 +760,7 @@ fn c53_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c54_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c54_l100_action_invoke"); let result = instance.call("reset", &[]); - + result.map(|_| ()) } @@ -743,7 +784,7 @@ fn c56_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c57_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c57_l103_action_invoke"); let result = instance.call("i64.store", &[]); - + result.map(|_| ()) } @@ -760,12 +801,15 @@ fn c59_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c59_l105_action_invoke"); let result = instance.call("f64.load", &[]); let expected = f64::from_bits(9219994337134247936); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -823,8 +867,11 @@ fn create_module_5() -> Box { (data (;0;) (i32.const 0) \"\\01\\00\\d0\\7f\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_5(instance: &mut Instance) { @@ -845,12 +892,15 @@ fn c62_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c62_l120_action_invoke"); let result = instance.call("f32.load", &[]); let expected = f32::from_bits(2144337921); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -858,7 +908,7 @@ fn c62_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c63_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c63_l121_action_invoke"); let result = instance.call("reset", &[]); - + result.map(|_| ()) } @@ -882,7 +932,7 @@ fn c65_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c66_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c66_l124_action_invoke"); let result = instance.call("f32.store", &[]); - + result.map(|_| ()) } @@ -899,12 +949,15 @@ fn c68_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c68_l126_action_invoke"); let result = instance.call("f32.load", &[]); let expected = f32::from_bits(2144337921); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -912,7 +965,7 @@ fn c68_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c69_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c69_l127_action_invoke"); let result = instance.call("reset", &[]); - + result.map(|_| ()) } @@ -936,7 +989,7 @@ fn c71_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c72_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c72_l130_action_invoke"); let result = instance.call("i32.store", &[]); - + result.map(|_| ()) } @@ -953,12 +1006,15 @@ fn c74_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c74_l132_action_invoke"); let result = instance.call("f32.load", &[]); let expected = f32::from_bits(2144337921); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -1016,8 +1072,11 @@ fn create_module_6() -> Box { (data (;0;) (i32.const 0) \"\\01\\00\\00\\00\\00\\00\\fc\\7f\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_6(instance: &mut Instance) { @@ -1038,12 +1097,15 @@ fn c77_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c77_l145_action_invoke"); let result = instance.call("f64.load", &[]); let expected = f64::from_bits(9222246136947933185); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -1051,7 +1113,7 @@ fn c77_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c78_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c78_l146_action_invoke"); let result = instance.call("reset", &[]); - + result.map(|_| ()) } @@ -1075,7 +1137,7 @@ fn c80_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c81_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c81_l149_action_invoke"); let result = instance.call("f64.store", &[]); - + result.map(|_| ()) } @@ -1092,12 +1154,15 @@ fn c83_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c83_l151_action_invoke"); let result = instance.call("f64.load", &[]); let expected = f64::from_bits(9222246136947933185); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -1105,7 +1170,7 @@ fn c83_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c84_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c84_l152_action_invoke"); let result = instance.call("reset", &[]); - + result.map(|_| ()) } @@ -1129,7 +1194,7 @@ fn c86_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c87_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c87_l155_action_invoke"); let result = instance.call("i64.store", &[]); - + result.map(|_| ()) } @@ -1146,12 +1211,15 @@ fn c89_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c89_l157_action_invoke"); let result = instance.call("f64.load", &[]); let expected = f64::from_bits(9222246136947933185); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } diff --git a/lib/runtime/tests/spectests/float_misc.rs b/lib/runtime/tests/spectests/float_misc.rs index 8c9c91c28..5d0ef6622 100644 --- a/lib/runtime/tests/spectests/float_misc.rs +++ b/lib/runtime/tests/spectests/float_misc.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 17 fn create_module_1() -> Box { @@ -153,8 +149,11 @@ fn create_module_1() -> Box { (export \"f64.max\" (func 27))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -165,7 +164,13 @@ fn start_module_1(instance: &mut Instance) { // Line 50 fn c1_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1_l50_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((1.1234568f32)), Value::F32((0.00000000012345f32))]); + let result = instance.call( + "f32.add", + &[ + Value::F32((1.1234568f32)), + Value::F32((0.00000000012345f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.1234568f32))))); result.map(|_| ()) } @@ -173,7 +178,13 @@ fn c1_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 51 fn c2_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2_l51_action_invoke"); - let result = instance.call("f64.add", &[Value::F64((1.123456789f64)), Value::F64((0.00000000012345f64))]); + let result = instance.call( + "f64.add", + &[ + Value::F64((1.123456789f64)), + Value::F64((0.00000000012345f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.12345678912345f64))))); result.map(|_| ()) } @@ -181,7 +192,10 @@ fn c2_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 55 fn c3_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c3_l55_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((1.0f32)), Value::F32((0.000000059604645f32))]); + let result = instance.call( + "f32.add", + &[Value::F32((1.0f32)), Value::F32((0.000000059604645f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -189,7 +203,10 @@ fn c3_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 56 fn c4_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c4_l56_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((1.0f32)), Value::F32((0.00000005960465f32))]); + let result = instance.call( + "f32.add", + &[Value::F32((1.0f32)), Value::F32((0.00000005960465f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0000001f32))))); result.map(|_| ()) } @@ -197,7 +214,13 @@ fn c4_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 57 fn c5_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c5_l57_action_invoke"); - let result = instance.call("f64.add", &[Value::F64((1.0f64)), Value::F64((0.00000000000000011102230246251565f64))]); + let result = instance.call( + "f64.add", + &[ + Value::F64((1.0f64)), + Value::F64((0.00000000000000011102230246251565f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -205,7 +228,13 @@ fn c5_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 58 fn c6_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c6_l58_action_invoke"); - let result = instance.call("f64.add", &[Value::F64((1.0f64)), Value::F64((0.00000000000000011102230246251568f64))]); + let result = instance.call( + "f64.add", + &[ + Value::F64((1.0f64)), + Value::F64((0.00000000000000011102230246251568f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64))))); result.map(|_| ()) } @@ -213,8 +242,19 @@ fn c6_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 61 fn c7_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c7_l61_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000000000001f32)), Value::F32((0.000000000000000000000000000000000000011754942f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((0.000000000000000000000000000000000000000000001f32)), + Value::F32((0.000000000000000000000000000000000000011754942f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } @@ -229,7 +269,10 @@ fn c8_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 67 fn c9_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c9_l67_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((2147483600.0f32)), Value::F32((1024.25f32))]); + let result = instance.call( + "f32.add", + &[Value::F32((2147483600.0f32)), Value::F32((1024.25f32))], + ); assert_eq!(result, Ok(Some(Value::F32((2147484700.0f32))))); result.map(|_| ()) } @@ -237,7 +280,13 @@ fn c9_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 68 fn c10_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c10_l68_action_invoke"); - let result = instance.call("f64.add", &[Value::F64((9223372036854776000.0f64)), Value::F64((1024.25f64))]); + let result = instance.call( + "f64.add", + &[ + Value::F64((9223372036854776000.0f64)), + Value::F64((1024.25f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((9223372036854778000.0f64))))); result.map(|_| ()) } @@ -253,7 +302,13 @@ fn c11_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 75 fn c12_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c12_l75_action_invoke"); - let result = instance.call("f64.add", &[Value::F64((9007199254740992.0f64)), Value::F64((1.00001f64))]); + let result = instance.call( + "f64.add", + &[ + Value::F64((9007199254740992.0f64)), + Value::F64((1.00001f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((9007199254740994.0f64))))); result.map(|_| ()) } @@ -261,7 +316,13 @@ fn c12_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 78 fn c13_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c13_l78_action_invoke"); - let result = instance.call("f64.add", &[Value::F64((9007199254740994.0f64)), Value::F64((0.9999847412109375f64))]); + let result = instance.call( + "f64.add", + &[ + Value::F64((9007199254740994.0f64)), + Value::F64((0.9999847412109375f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((9007199254740994.0f64))))); result.map(|_| ()) } @@ -269,7 +330,10 @@ fn c13_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 81 fn c14_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c14_l81_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((8388608.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "f32.add", + &[Value::F32((8388608.0f32)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((8388608.0f32))))); result.map(|_| ()) } @@ -277,7 +341,10 @@ fn c14_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 82 fn c15_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c15_l82_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((8388609.0f32)), Value::F32((0.5f32))]); + let result = instance.call( + "f32.add", + &[Value::F32((8388609.0f32)), Value::F32((0.5f32))], + ); assert_eq!(result, Ok(Some(Value::F32((8388610.0f32))))); result.map(|_| ()) } @@ -285,7 +352,10 @@ fn c15_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 83 fn c16_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c16_l83_action_invoke"); - let result = instance.call("f64.add", &[Value::F64((4503599627370496.0f64)), Value::F64((0.5f64))]); + let result = instance.call( + "f64.add", + &[Value::F64((4503599627370496.0f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((4503599627370496.0f64))))); result.map(|_| ()) } @@ -293,7 +363,10 @@ fn c16_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 84 fn c17_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c17_l84_action_invoke"); - let result = instance.call("f64.add", &[Value::F64((4503599627370497.0f64)), Value::F64((0.5f64))]); + let result = instance.call( + "f64.add", + &[Value::F64((4503599627370497.0f64)), Value::F64((0.5f64))], + ); assert_eq!(result, Ok(Some(Value::F64((4503599627370498.0f64))))); result.map(|_| ()) } @@ -301,15 +374,30 @@ fn c17_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 87 fn c18_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c18_l87_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((-6207600000000000000000000000000.0f32)), Value::F32((0.000000000000000000000000000002309799f32))]); - assert_eq!(result, Ok(Some(Value::F32((-6207600000000000000000000000000.0f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((-6207600000000000000000000000000.0f32)), + Value::F32((0.000000000000000000000000000002309799f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-6207600000000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 88 fn c19_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c19_l88_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((209865800000000000000.0f32)), Value::F32((-5270152500000000.0f32))]); + let result = instance.call( + "f32.add", + &[ + Value::F32((209865800000000000000.0f32)), + Value::F32((-5270152500000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((209860530000000000000.0f32))))); result.map(|_| ()) } @@ -317,15 +405,30 @@ fn c19_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 89 fn c20_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c20_l89_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((0.0000000000000000000000001963492f32)), Value::F32((0.000000000000000000000000000000000000046220067f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000001963492f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((0.0000000000000000000000001963492f32)), + Value::F32((0.000000000000000000000000000000000000046220067f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.0000000000000000000000001963492f32)))) + ); result.map(|_| ()) } // Line 90 fn c21_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c21_l90_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((640905000000.0f32)), Value::F32((-64449550000000000.0f32))]); + let result = instance.call( + "f32.add", + &[ + Value::F32((640905000000.0f32)), + Value::F32((-64449550000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-64448910000000000.0f32))))); result.map(|_| ()) } @@ -333,8 +436,17 @@ fn c21_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 91 fn c22_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c22_l91_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((0.0000601966f32)), Value::F32((120372790000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((120372790000000000000000000000000.0f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((0.0000601966f32)), + Value::F32((120372790000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((120372790000000000000000000000000.0f32)))) + ); result.map(|_| ()) } @@ -342,22 +454,44 @@ fn c22_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c23_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c23_l92_action_invoke"); let result = instance.call("f64.add", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009218993827002741f64)), Value::F64((-1283078243878048500000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-1283078243878048500000000000000000000000000000000000000000000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (-1283078243878048500000000000000000000000000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } // Line 93 fn c24_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c24_l93_action_invoke"); - let result = instance.call("f64.add", &[Value::F64((-96503407870148960000000.0f64)), Value::F64((0.00000000000000000000000000000000000000000000000000000004670208988478548f64))]); - assert_eq!(result, Ok(Some(Value::F64((-96503407870148960000000.0f64))))); + let result = instance.call( + "f64.add", + &[ + Value::F64((-96503407870148960000000.0f64)), + Value::F64( + (0.00000000000000000000000000000000000000000000000000000004670208988478548f64), + ), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64((-96503407870148960000000.0f64)))) + ); result.map(|_| ()) } // Line 94 fn c25_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c25_l94_action_invoke"); - let result = instance.call("f64.add", &[Value::F64((0.0000000000000000000000000000000000000000000028559147675434106f64)), Value::F64((-0.00026124280570653086f64))]); + let result = instance.call( + "f64.add", + &[ + Value::F64((0.0000000000000000000000000000000000000000000028559147675434106f64)), + Value::F64((-0.00026124280570653086f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-0.00026124280570653086f64))))); result.map(|_| ()) } @@ -381,7 +515,13 @@ fn c27_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 99 fn c28_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c28_l99_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((5238404000000000000000.0f32)), Value::F32((-1570182.5f32))]); + let result = instance.call( + "f32.add", + &[ + Value::F32((5238404000000000000000.0f32)), + Value::F32((-1570182.5f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((5238404000000000000000.0f32))))); result.map(|_| ()) } @@ -389,7 +529,13 @@ fn c28_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 100 fn c29_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c29_l100_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((0.00000000000004258938f32)), Value::F32((-0.0000000000000000000000057092353f32))]); + let result = instance.call( + "f32.add", + &[ + Value::F32((0.00000000000004258938f32)), + Value::F32((-0.0000000000000000000000057092353f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000000000004258938f32))))); result.map(|_| ()) } @@ -397,15 +543,32 @@ fn c29_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 101 fn c30_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c30_l101_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((-0.00000000000027251026f32)), Value::F32((83711560000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((83711560000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((-0.00000000000027251026f32)), + Value::F32((83711560000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (83711560000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 102 fn c31_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c31_l102_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((-0.0000000000000884536f32)), Value::F32((-0.000000000000000000000000000000015165626f32))]); + let result = instance.call( + "f32.add", + &[ + Value::F32((-0.0000000000000884536f32)), + Value::F32((-0.000000000000000000000000000000015165626f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000884536f32))))); result.map(|_| ()) } @@ -413,7 +576,13 @@ fn c31_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 103 fn c32_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c32_l103_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((0.0010521035f32)), Value::F32((-0.000000000000000000000000000000007582135f32))]); + let result = instance.call( + "f32.add", + &[ + Value::F32((0.0010521035f32)), + Value::F32((-0.000000000000000000000000000000007582135f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0010521035f32))))); result.map(|_| ()) } @@ -422,15 +591,31 @@ fn c32_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c33_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c33_l104_action_invoke"); let result = instance.call("f64.add", &[Value::F64((1511135228188924600000000000000000000000000000000000000.0f64)), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002760218100603169f64))]); - assert_eq!(result, Ok(Some(Value::F64((1511135228188924600000000000000000000000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (1511135228188924600000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } // Line 105 fn c34_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c34_l105_action_invoke"); - let result = instance.call("f64.add", &[Value::F64((62386719760360280000000000000000000000000000000.0f64)), Value::F64((-0.0000000000000000008592185488839212f64))]); - assert_eq!(result, Ok(Some(Value::F64((62386719760360280000000000000000000000000000000.0f64))))); + let result = instance.call( + "f64.add", + &[ + Value::F64((62386719760360280000000000000000000000000000000.0f64)), + Value::F64((-0.0000000000000000008592185488839212f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (62386719760360280000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -445,8 +630,19 @@ fn c35_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 107 fn c36_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c36_l107_action_invoke"); - let result = instance.call("f64.add", &[Value::F64((-215220546714824520000000000000000000000000000.0f64)), Value::F64((-1112220412047137200000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-216332767126871650000000000000000000000000000.0f64))))); + let result = instance.call( + "f64.add", + &[ + Value::F64((-215220546714824520000000000000000000000000000.0f64)), + Value::F64((-1112220412047137200000000000000000000000000.0f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (-216332767126871650000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -461,7 +657,13 @@ fn c37_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 111 fn c38_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c38_l111_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((-0.000000000000000000000000000000000006456021f32)), Value::F32((0.00000000000020219949f32))]); + let result = instance.call( + "f32.add", + &[ + Value::F32((-0.000000000000000000000000000000000006456021f32)), + Value::F32((0.00000000000020219949f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000000000020219949f32))))); result.map(|_| ()) } @@ -469,7 +671,13 @@ fn c38_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 112 fn c39_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c39_l112_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((-0.000026823169f32)), Value::F32((0.000000011196016f32))]); + let result = instance.call( + "f32.add", + &[ + Value::F32((-0.000026823169f32)), + Value::F32((0.000000011196016f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.000026811973f32))))); result.map(|_| ()) } @@ -477,7 +685,13 @@ fn c39_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 113 fn c40_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c40_l113_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((-128526170000.0f32)), Value::F32((0.0000000000000000000000000000000027356305f32))]); + let result = instance.call( + "f32.add", + &[ + Value::F32((-128526170000.0f32)), + Value::F32((0.0000000000000000000000000000000027356305f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-128526170000.0f32))))); result.map(|_| ()) } @@ -485,7 +699,13 @@ fn c40_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 114 fn c41_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c41_l114_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000004158973f32)), Value::F32((-1573528700.0f32))]); + let result = instance.call( + "f32.add", + &[ + Value::F32((0.000000000000000000000000000000000004158973f32)), + Value::F32((-1573528700.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-1573528700.0f32))))); result.map(|_| ()) } @@ -493,8 +713,17 @@ fn c41_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 115 fn c42_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c42_l115_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((-0.0000000000000000000000000000000000009338769f32)), Value::F32((78647514000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((78647514000000000000000000000.0f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((-0.0000000000000000000000000000000000009338769f32)), + Value::F32((78647514000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((78647514000000000000000000000.0f32)))) + ); result.map(|_| ()) } @@ -614,47 +843,107 @@ fn c56_l133_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c57_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c57_l134_action_invoke"); let result = instance.call("f64.add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000004165382103988111f64)), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010865942283516648f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000004165382103988111f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.000000000000000000000000000000000000000000000000000000000004165382103988111f64) + ))) + ); result.map(|_| ()) } // Line 137 fn c58_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c58_l137_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((97215650000000000000000000000000000.0f32)), Value::F32((305590870000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((305688080000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((97215650000000000000000000000000000.0f32)), + Value::F32((305590870000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (305688080000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 138 fn c59_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c59_l138_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((270465630000000000000000000000000000000.0f32)), Value::F32((-230236850000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((270465400000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((270465630000000000000000000000000000000.0f32)), + Value::F32((-230236850000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (270465400000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 139 fn c60_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c60_l139_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((357209300000000000000000000000000000.0f32)), Value::F32((-236494050000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-236136840000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((357209300000000000000000000000000000.0f32)), + Value::F32((-236494050000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-236136840000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 140 fn c61_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c61_l140_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((-1484234100000000000000000000000000000.0f32)), Value::F32((-328991400000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-330475620000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((-1484234100000000000000000000000000000.0f32)), + Value::F32((-328991400000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-330475620000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 141 fn c62_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c62_l141_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((-219885600000000000000000000000000000000.0f32)), Value::F32((-81560930000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-301446520000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((-219885600000000000000000000000000000000.0f32)), + Value::F32((-81560930000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-301446520000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -701,40 +990,95 @@ fn c67_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 149 fn c68_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c68_l149_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000008313455f32)), Value::F32((0.000000000000000000000000000000000000000000873f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000008314328f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((0.000000000000000000000000000000000000008313455f32)), + Value::F32((0.000000000000000000000000000000000000000000873f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000008314328f32) + ))) + ); result.map(|_| ()) } // Line 150 fn c69_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c69_l150_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000000000052f32)), Value::F32((-0.000000000000000000000000000000000000000000003f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000049f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((0.000000000000000000000000000000000000000000052f32)), + Value::F32((-0.000000000000000000000000000000000000000000003f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000049f32) + ))) + ); result.map(|_| ()) } // Line 151 fn c70_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c70_l151_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((-0.000000000000000000000000000000000000000000011f32)), Value::F32((0.000000000000000000000000000000000000005186284f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005186273f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000011f32)), + Value::F32((0.000000000000000000000000000000000000005186284f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000005186273f32) + ))) + ); result.map(|_| ()) } // Line 152 fn c71_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c71_l152_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((-0.000000000000000000000000000000000000000000028f32)), Value::F32((0.00000000000000000000000000000000000023675283f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000002367528f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((-0.000000000000000000000000000000000000000000028f32)), + Value::F32((0.00000000000000000000000000000000000023675283f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.0000000000000000000000000000000000002367528f32) + ))) + ); result.map(|_| ()) } // Line 153 fn c72_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c72_l153_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000000000635f32)), Value::F32((-0.00000000000000000000000000000000000000003327f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000032635f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((0.000000000000000000000000000000000000000000635f32)), + Value::F32((-0.00000000000000000000000000000000000000003327f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000000032635f32) + ))) + ); result.map(|_| ()) } @@ -781,8 +1125,19 @@ fn c77_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 162 fn c78_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c78_l162_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((340282330000000000000000000000000000000.0f32)), Value::F32((20282410000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((340282330000000000000000000000000000000.0f32)), + Value::F32((20282410000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -813,15 +1168,32 @@ fn c81_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 170 fn c82_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c82_l170_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((10141204000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((10141204000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 171 fn c83_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c83_l171_action_invoke"); - let result = instance.call("f32.add", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((10141205000000000000000000000000.0f32))]); + let result = instance.call( + "f32.add", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((10141205000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -845,7 +1217,13 @@ fn c85_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 177 fn c86_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c86_l177_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((65536.0f32)), Value::F32((0.000000000007275958f32))]); + let result = instance.call( + "f32.sub", + &[ + Value::F32((65536.0f32)), + Value::F32((0.000000000007275958f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((65536.0f32))))); result.map(|_| ()) } @@ -853,7 +1231,13 @@ fn c86_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 178 fn c87_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c87_l178_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((65536.0f64)), Value::F64((0.000000000007275957614183426f64))]); + let result = instance.call( + "f64.sub", + &[ + Value::F64((65536.0f64)), + Value::F64((0.000000000007275957614183426f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((65535.99999999999f64))))); result.map(|_| ()) } @@ -861,7 +1245,10 @@ fn c87_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 182 fn c88_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c88_l182_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((1.0f32)), Value::F32((0.000000029802322f32))]); + let result = instance.call( + "f32.sub", + &[Value::F32((1.0f32)), Value::F32((0.000000029802322f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -869,7 +1256,10 @@ fn c88_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 183 fn c89_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c89_l183_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((1.0f32)), Value::F32((0.000000029802326f32))]); + let result = instance.call( + "f32.sub", + &[Value::F32((1.0f32)), Value::F32((0.000000029802326f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.99999994f32))))); result.map(|_| ()) } @@ -877,7 +1267,13 @@ fn c89_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 184 fn c90_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c90_l184_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((1.0f64)), Value::F64((0.00000000000000005551115123125783f64))]); + let result = instance.call( + "f64.sub", + &[ + Value::F64((1.0f64)), + Value::F64((0.00000000000000005551115123125783f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -885,7 +1281,13 @@ fn c90_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 185 fn c91_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c91_l185_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((1.0f64)), Value::F64((0.00000000000000005551115123125784f64))]); + let result = instance.call( + "f64.sub", + &[ + Value::F64((1.0f64)), + Value::F64((0.00000000000000005551115123125784f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.9999999999999999f64))))); result.map(|_| ()) } @@ -893,23 +1295,51 @@ fn c91_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 188 fn c92_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c92_l188_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((0.00000000000000000000000000000002379208f32)), Value::F32((-722129800000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((722129800000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.sub", + &[ + Value::F32((0.00000000000000000000000000000002379208f32)), + Value::F32((-722129800000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (722129800000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 189 fn c93_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c93_l189_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((-842284000000000000000000000000000000.0f32)), Value::F32((-11118414000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-842284000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.sub", + &[ + Value::F32((-842284000000000000000000000000000000.0f32)), + Value::F32((-11118414000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-842284000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 190 fn c94_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c94_l190_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((1.4549444f32)), Value::F32((-0.00000000000000000000000033792615f32))]); + let result = instance.call( + "f32.sub", + &[ + Value::F32((1.4549444f32)), + Value::F32((-0.00000000000000000000000033792615f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.4549444f32))))); result.map(|_| ()) } @@ -917,15 +1347,30 @@ fn c94_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 191 fn c95_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c95_l191_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((0.0000000000000000000000000000000000094808914f32)), Value::F32((0.000000000000000000000018589502f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000018589502f32))))); + let result = instance.call( + "f32.sub", + &[ + Value::F32((0.0000000000000000000000000000000000094808914f32)), + Value::F32((0.000000000000000000000018589502f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-0.000000000000000000000018589502f32)))) + ); result.map(|_| ()) } // Line 192 fn c96_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c96_l192_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((0.000006181167f32)), Value::F32((-0.0000000000000000000000000000000093959864f32))]); + let result = instance.call( + "f32.sub", + &[ + Value::F32((0.000006181167f32)), + Value::F32((-0.0000000000000000000000000000000093959864f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.000006181167f32))))); result.map(|_| ()) } @@ -958,7 +1403,12 @@ fn c99_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c100_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c100_l196_action_invoke"); let result = instance.call("f64.sub", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000303879528930943f64)), Value::F64((-23204941114021897000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((23204941114021897000000000000000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (23204941114021897000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -966,30 +1416,59 @@ fn c100_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c101_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c101_l197_action_invoke"); let result = instance.call("f64.sub", &[Value::F64((-0.00000000000000000000000000000000000000000014953904039036317f64)), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010592252695645683f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000014953904039036317f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.00000000000000000000000000000000000000000014953904039036317f64) + ))) + ); result.map(|_| ()) } // Line 200 fn c102_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c102_l200_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((-448601660000000000000000000000000.0f32)), Value::F32((-8984148000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((8535546400000000000000000000000000.0f32))))); + let result = instance.call( + "f32.sub", + &[ + Value::F32((-448601660000000000000000000000000.0f32)), + Value::F32((-8984148000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((8535546400000000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 201 fn c103_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c103_l201_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((-899427400000000000000000000000000.0f32)), Value::F32((91.579384f32))]); - assert_eq!(result, Ok(Some(Value::F32((-899427400000000000000000000000000.0f32))))); + let result = instance.call( + "f32.sub", + &[ + Value::F32((-899427400000000000000000000000000.0f32)), + Value::F32((91.579384f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-899427400000000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 202 fn c104_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c104_l202_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((-0.00000000000000000000000011975f32)), Value::F32((0.000000063140405f32))]); + let result = instance.call( + "f32.sub", + &[ + Value::F32((-0.00000000000000000000000011975f32)), + Value::F32((0.000000063140405f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.000000063140405f32))))); result.map(|_| ()) } @@ -997,7 +1476,13 @@ fn c104_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 203 fn c105_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c105_l203_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((-0.000000000000000000000011800487f32)), Value::F32((-0.00031558736f32))]); + let result = instance.call( + "f32.sub", + &[ + Value::F32((-0.000000000000000000000011800487f32)), + Value::F32((-0.00031558736f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.00031558736f32))))); result.map(|_| ()) } @@ -1005,8 +1490,17 @@ fn c105_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 204 fn c106_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c106_l204_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((-736483800000000000000000000000.0f32)), Value::F32((0.0000000000000000030824513f32))]); - assert_eq!(result, Ok(Some(Value::F32((-736483800000000000000000000000.0f32))))); + let result = instance.call( + "f32.sub", + &[ + Value::F32((-736483800000000000000000000000.0f32)), + Value::F32((0.0000000000000000030824513f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-736483800000000000000000000000.0f32)))) + ); result.map(|_| ()) } @@ -1030,7 +1524,12 @@ fn c108_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c109_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c109_l207_action_invoke"); let result = instance.call("f64.sub", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000009719219783531962f64)), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001572015082308034f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000009719219783531962f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.0000000000000000000000000000000000000000000000000000000000009719219783531962f64) + ))) + ); result.map(|_| ()) } @@ -1045,23 +1544,49 @@ fn c110_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 209 fn c111_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c111_l209_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((-7538298763725556000000000000000000.0f64)), Value::F64((4447012580193329000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-4447012580193329000000000000000000000000000000000000.0f64))))); + let result = instance.call( + "f64.sub", + &[ + Value::F64((-7538298763725556000000000000000000.0f64)), + Value::F64((4447012580193329000000000000000000000000000000000000.0f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (-4447012580193329000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } // Line 212 fn c112_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c112_l212_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((75846976000000000000000000000.0f32)), Value::F32((0.000046391753f32))]); - assert_eq!(result, Ok(Some(Value::F32((75846976000000000000000000000.0f32))))); + let result = instance.call( + "f32.sub", + &[ + Value::F32((75846976000000000000000000000.0f32)), + Value::F32((0.000046391753f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((75846976000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 213 fn c113_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c113_l213_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((-567139.9f32)), Value::F32((-0.000000000030334842f32))]); + let result = instance.call( + "f32.sub", + &[ + Value::F32((-567139.9f32)), + Value::F32((-0.000000000030334842f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-567139.9f32))))); result.map(|_| ()) } @@ -1069,7 +1594,13 @@ fn c113_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 214 fn c114_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c114_l214_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((-0.000000000017412261f32)), Value::F32((-0.000000000000000017877793f32))]); + let result = instance.call( + "f32.sub", + &[ + Value::F32((-0.000000000017412261f32)), + Value::F32((-0.000000000000000017877793f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.000000000017412244f32))))); result.map(|_| ()) } @@ -1077,7 +1608,13 @@ fn c114_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 215 fn c115_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c115_l215_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((-0.000065645545f32)), Value::F32((0.00014473806f32))]); + let result = instance.call( + "f32.sub", + &[ + Value::F32((-0.000065645545f32)), + Value::F32((0.00014473806f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.00021038362f32))))); result.map(|_| ()) } @@ -1085,7 +1622,13 @@ fn c115_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 216 fn c116_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c116_l216_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((-0.00000000016016115f32)), Value::F32((-0.000000000000000000000000000000085380075f32))]); + let result = instance.call( + "f32.sub", + &[ + Value::F32((-0.00000000016016115f32)), + Value::F32((-0.000000000000000000000000000000085380075f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.00000000016016115f32))))); result.map(|_| ()) } @@ -1110,7 +1653,12 @@ fn c118_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c119_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c119_l219_action_invoke"); let result = instance.call("f64.sub", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036288281010831153f64)), Value::F64((3383199683245004400000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-3383199683245004400000000000000000000000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (-3383199683245004400000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -1133,8 +1681,19 @@ fn c121_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 224 fn c122_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c122_l224_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((0.000000000000000000000005816988065793039f64)), Value::F64((0.000000000000000000000000000000000025021499241540866f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000005816988065768018f64))))); + let result = instance.call( + "f64.sub", + &[ + Value::F64((0.000000000000000000000005816988065793039f64)), + Value::F64((0.000000000000000000000000000000000025021499241540866f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.000000000000000000000005816988065768018f64) + ))) + ); result.map(|_| ()) } @@ -1150,22 +1709,42 @@ fn c123_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c124_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c124_l226_action_invoke"); let result = instance.call("f64.sub", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000006908052676315257f64)), Value::F64((0.0000000000000000000000000000000000000000000000000000000000012001773734799856f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000012001773734799856f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.0000000000000000000000000000000000000000000000000000000000012001773734799856f64) + ))) + ); result.map(|_| ()) } // Line 227 fn c125_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c125_l227_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((-0.0000000000022044291547443813f64)), Value::F64((-0.0000000000000000000027947429925618632f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.000000000002204429151949638f64))))); + let result = instance.call( + "f64.sub", + &[ + Value::F64((-0.0000000000022044291547443813f64)), + Value::F64((-0.0000000000000000000027947429925618632f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64((-0.000000000002204429151949638f64)))) + ); result.map(|_| ()) } // Line 228 fn c126_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c126_l228_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((0.00000004016393569117761f64)), Value::F64((0.17053881989395447f64))]); + let result = instance.call( + "f64.sub", + &[ + Value::F64((0.00000004016393569117761f64)), + Value::F64((0.17053881989395447f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((-0.17053877973001877f64))))); result.map(|_| ()) } @@ -1190,7 +1769,10 @@ fn c128_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c129_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c129_l233_action_invoke"); let result = instance.call("f64.sub", &[Value::F64((38832071540376680000000000000000000.0f64)), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042192279274320304f64))]); - assert_eq!(result, Ok(Some(Value::F64((38832071540376680000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((38832071540376680000000000000000000.0f64)))) + ); result.map(|_| ()) } @@ -1206,14 +1788,20 @@ fn c130_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c131_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c131_l235_action_invoke"); let result = instance.call("f64.sub", &[Value::F64((0.00000000000000000949378346261834f64)), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014584885434950294f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000949378346261834f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((0.00000000000000000949378346261834f64)))) + ); result.map(|_| ()) } // Line 239 fn c132_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c132_l239_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((23.140692f32)), Value::F32((3.1415927f32))]); + let result = instance.call( + "f32.sub", + &[Value::F32((23.140692f32)), Value::F32((3.1415927f32))], + ); assert_eq!(result, Ok(Some(Value::F32((19.9991f32))))); result.map(|_| ()) } @@ -1221,7 +1809,13 @@ fn c132_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 240 fn c133_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c133_l240_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((23.14069263277927f64)), Value::F64((3.141592653589793f64))]); + let result = instance.call( + "f64.sub", + &[ + Value::F64((23.14069263277927f64)), + Value::F64((3.141592653589793f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((19.999099979189477f64))))); result.map(|_| ()) } @@ -1229,7 +1823,10 @@ fn c133_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 243 fn c134_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c134_l243_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((2999999.0f32)), Value::F32((2999998.0f32))]); + let result = instance.call( + "f32.sub", + &[Value::F32((2999999.0f32)), Value::F32((2999998.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1237,7 +1834,10 @@ fn c134_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 244 fn c135_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c135_l244_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((1999999.0f32)), Value::F32((1999995.0f32))]); + let result = instance.call( + "f32.sub", + &[Value::F32((1999999.0f32)), Value::F32((1999995.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((4.0f32))))); result.map(|_| ()) } @@ -1245,7 +1845,10 @@ fn c135_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 245 fn c136_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c136_l245_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((1999999.0f32)), Value::F32((1999993.0f32))]); + let result = instance.call( + "f32.sub", + &[Value::F32((1999999.0f32)), Value::F32((1999993.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((6.0f32))))); result.map(|_| ()) } @@ -1253,7 +1856,10 @@ fn c136_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 246 fn c137_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c137_l246_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((400002.0f32)), Value::F32((400001.0f32))]); + let result = instance.call( + "f32.sub", + &[Value::F32((400002.0f32)), Value::F32((400001.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1261,7 +1867,10 @@ fn c137_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 247 fn c138_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c138_l247_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((400002.0f32)), Value::F32((400000.0f32))]); + let result = instance.call( + "f32.sub", + &[Value::F32((400002.0f32)), Value::F32((400000.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((2.0f32))))); result.map(|_| ()) } @@ -1269,7 +1878,13 @@ fn c138_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 248 fn c139_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c139_l248_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((2999999999999999.0f64)), Value::F64((2999999999999998.0f64))]); + let result = instance.call( + "f64.sub", + &[ + Value::F64((2999999999999999.0f64)), + Value::F64((2999999999999998.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -1277,7 +1892,13 @@ fn c139_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 249 fn c140_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c140_l249_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((1999999999999999.0f64)), Value::F64((1999999999999995.0f64))]); + let result = instance.call( + "f64.sub", + &[ + Value::F64((1999999999999999.0f64)), + Value::F64((1999999999999995.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((4.0f64))))); result.map(|_| ()) } @@ -1285,7 +1906,13 @@ fn c140_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 250 fn c141_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c141_l250_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((1999999999999999.0f64)), Value::F64((1999999999999993.0f64))]); + let result = instance.call( + "f64.sub", + &[ + Value::F64((1999999999999999.0f64)), + Value::F64((1999999999999993.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((6.0f64))))); result.map(|_| ()) } @@ -1293,7 +1920,13 @@ fn c141_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 251 fn c142_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c142_l251_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((400000000000002.0f64)), Value::F64((400000000000001.0f64))]); + let result = instance.call( + "f64.sub", + &[ + Value::F64((400000000000002.0f64)), + Value::F64((400000000000001.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -1301,7 +1934,13 @@ fn c142_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 252 fn c143_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c143_l252_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((400000000000002.0f64)), Value::F64((400000000000000.0f64))]); + let result = instance.call( + "f64.sub", + &[ + Value::F64((400000000000002.0f64)), + Value::F64((400000000000000.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((2.0f64))))); result.map(|_| ()) } @@ -1309,8 +1948,19 @@ fn c143_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 255 fn c144_l255_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c144_l255_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754942f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "f32.sub", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754942f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } @@ -1325,7 +1975,10 @@ fn c145_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 259 fn c146_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c146_l259_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((1.0000001f32)), Value::F32((0.99999994f32))]); + let result = instance.call( + "f32.sub", + &[Value::F32((1.0000001f32)), Value::F32((0.99999994f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000017881393f32))))); result.map(|_| ()) } @@ -1333,7 +1986,10 @@ fn c146_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 260 fn c147_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c147_l260_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((1.0000001f32)), Value::F32((1.0f32))]); + let result = instance.call( + "f32.sub", + &[Value::F32((1.0000001f32)), Value::F32((1.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000011920929f32))))); result.map(|_| ()) } @@ -1341,7 +1997,10 @@ fn c147_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 261 fn c148_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c148_l261_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((1.0f32)), Value::F32((0.99999994f32))]); + let result = instance.call( + "f32.sub", + &[Value::F32((1.0f32)), Value::F32((0.99999994f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.000000059604645f32))))); result.map(|_| ()) } @@ -1349,40 +2008,83 @@ fn c148_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 262 fn c149_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c149_l262_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((1.0000000000000002f64)), Value::F64((0.9999999999999999f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.00000000000000033306690738754696f64))))); + let result = instance.call( + "f64.sub", + &[ + Value::F64((1.0000000000000002f64)), + Value::F64((0.9999999999999999f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64((0.00000000000000033306690738754696f64)))) + ); result.map(|_| ()) } // Line 263 fn c150_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c150_l263_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((1.0000000000000002f64)), Value::F64((1.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64))))); + let result = instance.call( + "f64.sub", + &[Value::F64((1.0000000000000002f64)), Value::F64((1.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F64((0.0000000000000002220446049250313f64)))) + ); result.map(|_| ()) } // Line 264 fn c151_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c151_l264_action_invoke"); - let result = instance.call("f64.sub", &[Value::F64((1.0f64)), Value::F64((0.9999999999999999f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.00000000000000011102230246251565f64))))); + let result = instance.call( + "f64.sub", + &[Value::F64((1.0f64)), Value::F64((0.9999999999999999f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F64((0.00000000000000011102230246251565f64)))) + ); result.map(|_| ()) } // Line 268 fn c152_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c152_l268_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((10141204000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((10141204000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282350000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 269 fn c153_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c153_l269_action_invoke"); - let result = instance.call("f32.sub", &[Value::F32((340282350000000000000000000000000000000.0f32)), Value::F32((10141205000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282330000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.sub", + &[ + Value::F32((340282350000000000000000000000000000000.0f32)), + Value::F32((10141205000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282330000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -1405,15 +2107,30 @@ fn c155_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 274 fn c156_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c156_l274_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((1000000000000000.0f32)), Value::F32((1000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((999999940000000000000000000000.0f32))))); + let result = instance.call( + "f32.mul", + &[ + Value::F32((1000000000000000.0f32)), + Value::F32((1000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((999999940000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 275 fn c157_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c157_l275_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((100000000000000000000.0f32)), Value::F32((100000000000000000000.0f32))]); + let result = instance.call( + "f32.mul", + &[ + Value::F32((100000000000000000000.0f32)), + Value::F32((100000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -1421,7 +2138,13 @@ fn c157_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 276 fn c158_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c158_l276_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((10000000000000000000000000.0f32)), Value::F32((10000000000000000000000000.0f32))]); + let result = instance.call( + "f32.mul", + &[ + Value::F32((10000000000000000000000000.0f32)), + Value::F32((10000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -1429,31 +2152,68 @@ fn c158_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 277 fn c159_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c159_l277_action_invoke"); - let result = instance.call("f64.mul", &[Value::F64((1000000000000000.0f64)), Value::F64((1000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((1000000000000000000000000000000.0f64))))); + let result = instance.call( + "f64.mul", + &[ + Value::F64((1000000000000000.0f64)), + Value::F64((1000000000000000.0f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64((1000000000000000000000000000000.0f64)))) + ); result.map(|_| ()) } // Line 278 fn c160_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c160_l278_action_invoke"); - let result = instance.call("f64.mul", &[Value::F64((100000000000000000000.0f64)), Value::F64((100000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((10000000000000000000000000000000000000000.0f64))))); + let result = instance.call( + "f64.mul", + &[ + Value::F64((100000000000000000000.0f64)), + Value::F64((100000000000000000000.0f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (10000000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } // Line 279 fn c161_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c161_l279_action_invoke"); - let result = instance.call("f64.mul", &[Value::F64((10000000000000000000000000.0f64)), Value::F64((10000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((100000000000000030000000000000000000000000000000000.0f64))))); + let result = instance.call( + "f64.mul", + &[ + Value::F64((10000000000000000000000000.0f64)), + Value::F64((10000000000000000000000000.0f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (100000000000000030000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } // Line 284 fn c162_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c162_l284_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((1848874900.0f32)), Value::F32((19954563000.0f32))]); + let result = instance.call( + "f32.mul", + &[ + Value::F32((1848874900.0f32)), + Value::F32((19954563000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((36893493000000000000.0f32))))); result.map(|_| ()) } @@ -1461,7 +2221,13 @@ fn c162_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 285 fn c163_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c163_l285_action_invoke"); - let result = instance.call("f64.mul", &[Value::F64((1848874847.0f64)), Value::F64((19954562207.0f64))]); + let result = instance.call( + "f64.mul", + &[ + Value::F64((1848874847.0f64)), + Value::F64((19954562207.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((36893488147419110000.0f64))))); result.map(|_| ()) } @@ -1485,7 +2251,13 @@ fn c165_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 293 fn c166_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c166_l293_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((-2493839400000000000.0f32)), Value::F32((0.000000000021176054f32))]); + let result = instance.call( + "f32.mul", + &[ + Value::F32((-2493839400000000000.0f32)), + Value::F32((0.000000000021176054f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-52809680.0f32))))); result.map(|_| ()) } @@ -1493,7 +2265,13 @@ fn c166_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 294 fn c167_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c167_l294_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((-6777248400000000000000000000000.0f32)), Value::F32((-0.00000000000000000000000000000034758242f32))]); + let result = instance.call( + "f32.mul", + &[ + Value::F32((-6777248400000000000000000000000.0f32)), + Value::F32((-0.00000000000000000000000000000034758242f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((2.3556523f32))))); result.map(|_| ()) } @@ -1501,7 +2279,13 @@ fn c167_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 295 fn c168_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c168_l295_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((-8384397600000000000000000000.0f32)), Value::F32((-0.000000000000000000000000000011948991f32))]); + let result = instance.call( + "f32.mul", + &[ + Value::F32((-8384397600000000000000000000.0f32)), + Value::F32((-0.000000000000000000000000000011948991f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.10018509f32))))); result.map(|_| ()) } @@ -1509,7 +2293,13 @@ fn c168_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 296 fn c169_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c169_l296_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((-656765400000000000000000.0f32)), Value::F32((-0.000000000000000000000046889766f32))]); + let result = instance.call( + "f32.mul", + &[ + Value::F32((-656765400000000000000000.0f32)), + Value::F32((-0.000000000000000000000046889766f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((30.795576f32))))); result.map(|_| ()) } @@ -1517,7 +2307,13 @@ fn c169_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 297 fn c170_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c170_l297_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((13328204000000000.0f32)), Value::F32((45.567223f32))]); + let result = instance.call( + "f32.mul", + &[ + Value::F32((13328204000000000.0f32)), + Value::F32((45.567223f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((607329200000000000.0f32))))); result.map(|_| ()) } @@ -1558,14 +2354,23 @@ fn c174_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c175_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c175_l302_action_invoke"); let result = instance.call("f64.mul", &[Value::F64((253838958331769250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007842892881810105f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000019908317594263248f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((0.00000000000000000019908317594263248f64)))) + ); result.map(|_| ()) } // Line 305 fn c176_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c176_l305_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((-0.0000000000000000000000000020153333f32)), Value::F32((-5031353000000000000000000000.0f32))]); + let result = instance.call( + "f32.mul", + &[ + Value::F32((-0.0000000000000000000000000020153333f32)), + Value::F32((-5031353000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((10.139854f32))))); result.map(|_| ()) } @@ -1573,15 +2378,30 @@ fn c176_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 306 fn c177_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c177_l306_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((12286325000000000000000.0f32)), Value::F32((749601.8f32))]); - assert_eq!(result, Ok(Some(Value::F32((9209852000000000000000000000.0f32))))); + let result = instance.call( + "f32.mul", + &[ + Value::F32((12286325000000000000000.0f32)), + Value::F32((749601.8f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((9209852000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 307 fn c178_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c178_l307_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((-0.0000000002763514f32)), Value::F32((-35524714000000000000000.0f32))]); + let result = instance.call( + "f32.mul", + &[ + Value::F32((-0.0000000002763514f32)), + Value::F32((-35524714000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((9817304000000.0f32))))); result.map(|_| ()) } @@ -1589,16 +2409,34 @@ fn c178_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 308 fn c179_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c179_l308_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((218931220000000000000.0f32)), Value::F32((-40298.785f32))]); - assert_eq!(result, Ok(Some(Value::F32((-8822662000000000000000000.0f32))))); + let result = instance.call( + "f32.mul", + &[ + Value::F32((218931220000000000000.0f32)), + Value::F32((-40298.785f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-8822662000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 309 fn c180_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c180_l309_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((1691996300.0f32)), Value::F32((-122103350000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-206598410000000000000000000000.0f32))))); + let result = instance.call( + "f32.mul", + &[ + Value::F32((1691996300.0f32)), + Value::F32((-122103350000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-206598410000000000000000000000.0f32)))) + ); result.map(|_| ()) } @@ -1645,7 +2483,13 @@ fn c185_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 317 fn c186_l317_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c186_l317_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((-110087030000000.0f32)), Value::F32((-54038020000000000000000000000.0f32))]); + let result = instance.call( + "f32.mul", + &[ + Value::F32((-110087030000000.0f32)), + Value::F32((-54038020000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -1653,23 +2497,49 @@ fn c186_l317_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 318 fn c187_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c187_l318_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((-0.19366351f32)), Value::F32((0.0000000000000000000000000000029748954f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000000000005761287f32))))); + let result = instance.call( + "f32.mul", + &[ + Value::F32((-0.19366351f32)), + Value::F32((0.0000000000000000000000000000029748954f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.0000000000000000000000000000005761287f32) + ))) + ); result.map(|_| ()) } // Line 319 fn c188_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c188_l319_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((-0.0000034300713f32)), Value::F32((77991523000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-267516490000000000000000000.0f32))))); + let result = instance.call( + "f32.mul", + &[ + Value::F32((-0.0000034300713f32)), + Value::F32((77991523000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-267516490000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 320 fn c189_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c189_l320_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((-99003850000000000.0f32)), Value::F32((0.000000000000000000000000000020933774f32))]); + let result = instance.call( + "f32.mul", + &[ + Value::F32((-99003850000000000.0f32)), + Value::F32((0.000000000000000000000000000020933774f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.0000000000020725242f32))))); result.map(|_| ()) } @@ -1677,8 +2547,19 @@ fn c189_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 321 fn c190_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c190_l321_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((-129919.07f32)), Value::F32((0.0000000000000000000000000000000000018480999f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000024010342f32))))); + let result = instance.call( + "f32.mul", + &[ + Value::F32((-129919.07f32)), + Value::F32((0.0000000000000000000000000000000000018480999f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.00000000000000000000000000000024010342f32) + ))) + ); result.map(|_| ()) } @@ -1686,7 +2567,10 @@ fn c190_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c191_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c191_l322_action_invoke"); let result = instance.call("f64.mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006625572200844895f64)), Value::F64((-37374020681740010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000024762427246273877f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((0.00000000000000000024762427246273877f64)))) + ); result.map(|_| ()) } @@ -1717,8 +2601,19 @@ fn c194_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 326 fn c195_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c195_l326_action_invoke"); - let result = instance.call("f64.mul", &[Value::F64((3407037798802672000000000.0f64)), Value::F64((1225791423971563000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((4176317714919266400000000000000000000000000000.0f64))))); + let result = instance.call( + "f64.mul", + &[ + Value::F64((3407037798802672000000000.0f64)), + Value::F64((1225791423971563000000.0f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (4176317714919266400000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -1806,23 +2701,46 @@ fn c205_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c206_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c206_l343_action_invoke"); let result = instance.call("f64.mul", &[Value::F64((46576441629501554000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007021344893525714f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.000000003270292605938992f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((0.000000003270292605938992f64)))) + ); result.map(|_| ()) } // Line 344 fn c207_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c207_l344_action_invoke"); - let result = instance.call("f64.mul", &[Value::F64((0.012451716278313712f64)), Value::F64((0.000000000000000000000000000000000000000000001945309177849331f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000002422243795617958f64))))); + let result = instance.call( + "f64.mul", + &[ + Value::F64((0.012451716278313712f64)), + Value::F64((0.000000000000000000000000000000000000000000001945309177849331f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.00000000000000000000000000000000000000000000002422243795617958f64) + ))) + ); result.map(|_| ()) } // Line 345 fn c208_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c208_l345_action_invoke"); - let result = instance.call("f64.mul", &[Value::F64((-3.8312314777598586f64)), Value::F64((0.0000000000009039887741742674f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000034633902471580017f64))))); + let result = instance.call( + "f64.mul", + &[ + Value::F64((-3.8312314777598586f64)), + Value::F64((0.0000000000009039887741742674f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64((-0.0000000000034633902471580017f64)))) + ); result.map(|_| ()) } @@ -1845,7 +2763,13 @@ fn c210_l347_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 350 fn c211_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c211_l350_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((0.00000000000000000000002646978f32)), Value::F32((0.00000000000000000000002646978f32))]); + let result = instance.call( + "f32.mul", + &[ + Value::F32((0.00000000000000000000002646978f32)), + Value::F32((0.00000000000000000000002646978f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -1853,8 +2777,19 @@ fn c211_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 351 fn c212_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c212_l351_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((0.000000000000000000000026469783f32)), Value::F32((0.000000000000000000000026469783f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "f32.mul", + &[ + Value::F32((0.000000000000000000000026469783f32)), + Value::F32((0.000000000000000000000026469783f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } @@ -1877,15 +2812,32 @@ fn c214_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 356 fn c215_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c215_l356_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((18446743000000000000.0f32)), Value::F32((18446743000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282330000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.mul", + &[ + Value::F32((18446743000000000000.0f32)), + Value::F32((18446743000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282330000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 357 fn c216_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c216_l357_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((18446744000000000000.0f32)), Value::F32((18446744000000000000.0f32))]); + let result = instance.call( + "f32.mul", + &[ + Value::F32((18446744000000000000.0f32)), + Value::F32((18446744000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -1909,7 +2861,10 @@ fn c218_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 362 fn c219_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c219_l362_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((1.0000001f32)), Value::F32((1.0000001f32))]); + let result = instance.call( + "f32.mul", + &[Value::F32((1.0000001f32)), Value::F32((1.0000001f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0000002f32))))); result.map(|_| ()) } @@ -1917,7 +2872,10 @@ fn c219_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 363 fn c220_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c220_l363_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((0.99999994f32)), Value::F32((0.99999994f32))]); + let result = instance.call( + "f32.mul", + &[Value::F32((0.99999994f32)), Value::F32((0.99999994f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.9999999f32))))); result.map(|_| ()) } @@ -1925,7 +2883,13 @@ fn c220_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 364 fn c221_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c221_l364_action_invoke"); - let result = instance.call("f64.mul", &[Value::F64((1.0000000000000002f64)), Value::F64((1.0000000000000002f64))]); + let result = instance.call( + "f64.mul", + &[ + Value::F64((1.0000000000000002f64)), + Value::F64((1.0000000000000002f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0000000000000004f64))))); result.map(|_| ()) } @@ -1933,7 +2897,13 @@ fn c221_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 365 fn c222_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c222_l365_action_invoke"); - let result = instance.call("f64.mul", &[Value::F64((0.9999999999999999f64)), Value::F64((0.9999999999999999f64))]); + let result = instance.call( + "f64.mul", + &[ + Value::F64((0.9999999999999999f64)), + Value::F64((0.9999999999999999f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.9999999999999998f64))))); result.map(|_| ()) } @@ -1941,7 +2911,10 @@ fn c222_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 368 fn c223_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c223_l368_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((1.0000001f32)), Value::F32((0.99999994f32))]); + let result = instance.call( + "f32.mul", + &[Value::F32((1.0000001f32)), Value::F32((0.99999994f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -1949,7 +2922,10 @@ fn c223_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 369 fn c224_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c224_l369_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((1.0000002f32)), Value::F32((0.9999999f32))]); + let result = instance.call( + "f32.mul", + &[Value::F32((1.0000002f32)), Value::F32((0.9999999f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0000001f32))))); result.map(|_| ()) } @@ -1957,7 +2933,13 @@ fn c224_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 370 fn c225_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c225_l370_action_invoke"); - let result = instance.call("f64.mul", &[Value::F64((1.0000000000000002f64)), Value::F64((0.9999999999999999f64))]); + let result = instance.call( + "f64.mul", + &[ + Value::F64((1.0000000000000002f64)), + Value::F64((0.9999999999999999f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -1965,7 +2947,13 @@ fn c225_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 371 fn c226_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c226_l371_action_invoke"); - let result = instance.call("f64.mul", &[Value::F64((1.0000000000000004f64)), Value::F64((0.9999999999999998f64))]); + let result = instance.call( + "f64.mul", + &[ + Value::F64((1.0000000000000004f64)), + Value::F64((0.9999999999999998f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64))))); result.map(|_| ()) } @@ -1973,8 +2961,19 @@ fn c226_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 375 fn c227_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c227_l375_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.00000011920929f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "f32.mul", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.00000011920929f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } @@ -1989,15 +2988,29 @@ fn c228_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 379 fn c229_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c229_l379_action_invoke"); - let result = instance.call("f32.mul", &[Value::F32((-16.001465f32)), Value::F32((0.000000000000000000000000000000000000000298465f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000004775883f32))))); + let result = instance.call( + "f32.mul", + &[ + Value::F32((-16.001465f32)), + Value::F32((0.000000000000000000000000000000000000000298465f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-0.000000000000000000000000000000000000004775883f32) + ))) + ); result.map(|_| ()) } // Line 382 fn c230_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c230_l382_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((1.1234568f32)), Value::F32((100.0f32))]); + let result = instance.call( + "f32.div", + &[Value::F32((1.1234568f32)), Value::F32((100.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.011234568f32))))); result.map(|_| ()) } @@ -2005,7 +3018,10 @@ fn c230_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 383 fn c231_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c231_l383_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((8391667.0f32)), Value::F32((12582905.0f32))]); + let result = instance.call( + "f32.div", + &[Value::F32((8391667.0f32)), Value::F32((12582905.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.6669102f32))))); result.map(|_| ()) } @@ -2013,7 +3029,13 @@ fn c231_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 384 fn c232_l384_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c232_l384_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((65536.0f32)), Value::F32((0.000000000007275958f32))]); + let result = instance.call( + "f32.div", + &[ + Value::F32((65536.0f32)), + Value::F32((0.000000000007275958f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((9007199000000000.0f32))))); result.map(|_| ()) } @@ -2021,8 +3043,19 @@ fn c232_l384_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 385 fn c233_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c233_l385_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((1.8622957f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005472795f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((1.8622957f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000005472795f32) + ))) + ); result.map(|_| ()) } @@ -2037,7 +3070,10 @@ fn c234_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 387 fn c235_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c235_l387_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((1.123456789f64)), Value::F64((100.0f64))]); + let result = instance.call( + "f64.div", + &[Value::F64((1.123456789f64)), Value::F64((100.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.01123456789f64))))); result.map(|_| ()) } @@ -2045,7 +3081,10 @@ fn c235_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 388 fn c236_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c236_l388_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((8391667.0f64)), Value::F64((12582905.0f64))]); + let result = instance.call( + "f64.div", + &[Value::F64((8391667.0f64)), Value::F64((12582905.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.6669101451532854f64))))); result.map(|_| ()) } @@ -2053,7 +3092,13 @@ fn c236_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 389 fn c237_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c237_l389_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((65536.0f64)), Value::F64((0.000000000007275957614183426f64))]); + let result = instance.call( + "f64.div", + &[ + Value::F64((65536.0f64)), + Value::F64((0.000000000007275957614183426f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((9007199254740992.0f64))))); result.map(|_| ()) } @@ -2077,7 +3122,10 @@ fn c239_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 395 fn c240_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c240_l395_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((4195835.0f32)), Value::F32((3145727.0f32))]); + let result = instance.call( + "f32.div", + &[Value::F32((4195835.0f32)), Value::F32((3145727.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.3338205f32))))); result.map(|_| ()) } @@ -2085,7 +3133,10 @@ fn c240_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 396 fn c241_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c241_l396_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((4195835.0f64)), Value::F64((3145727.0f64))]); + let result = instance.call( + "f64.div", + &[Value::F64((4195835.0f64)), Value::F64((3145727.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((1.333820449136241f64))))); result.map(|_| ()) } @@ -2093,7 +3144,13 @@ fn c241_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 399 fn c242_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c242_l399_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((0.000000000000005029633f32)), Value::F32((336324380000000000000000000000000000000.0f32))]); + let result = instance.call( + "f32.div", + &[ + Value::F32((0.000000000000005029633f32)), + Value::F32((336324380000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -2101,7 +3158,13 @@ fn c242_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 400 fn c243_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c243_l400_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((0.000000000000000000000000008921987f32)), Value::F32((354097530000000000000.0f32))]); + let result = instance.call( + "f32.div", + &[ + Value::F32((0.000000000000000000000000008921987f32)), + Value::F32((354097530000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -2109,15 +3172,30 @@ fn c243_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 401 fn c244_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c244_l401_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((-104167.47f32)), Value::F32((0.0000000000000000000000015866623f32))]); - assert_eq!(result, Ok(Some(Value::F32((-65651950000000000000000000000.0f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((-104167.47f32)), + Value::F32((0.0000000000000000000000015866623f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-65651950000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 402 fn c245_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c245_l402_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((-0.000000000000000000000024938657f32)), Value::F32((-0.00000000000000000000000000000000000036230088f32))]); + let result = instance.call( + "f32.div", + &[ + Value::F32((-0.000000000000000000000024938657f32)), + Value::F32((-0.00000000000000000000000000000000000036230088f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((68834107000000.0f32))))); result.map(|_| ()) } @@ -2125,16 +3203,38 @@ fn c245_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 403 fn c246_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c246_l403_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((-4142204200000.0f32)), Value::F32((0.0000000000000000000000011954948f32))]); - assert_eq!(result, Ok(Some(Value::F32((-3464845000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((-4142204200000.0f32)), + Value::F32((0.0000000000000000000000011954948f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (-3464845000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } // Line 404 fn c247_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c247_l404_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((193901163824483840000000000000000000000000000.0f64)), Value::F64((25290742357348314000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000007666883046955921f64))))); + let result = instance.call( + "f64.div", + &[ + Value::F64((193901163824483840000000000000000000000000000.0f64)), + Value::F64((25290742357348314000000000000000000000000000000000000000000000000000.0f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.000000000000000000000007666883046955921f64) + ))) + ); result.map(|_| ()) } @@ -2166,14 +3266,23 @@ fn c250_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c251_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c251_l408_action_invoke"); let result = instance.call("f64.div", &[Value::F64((-4566268877844991000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((31282495822334530000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-145968816036246260000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64((-145968816036246260000000000.0f64)))) + ); result.map(|_| ()) } // Line 411 fn c252_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c252_l411_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((-1039406400000000000000.0f32)), Value::F32((-0.000000000000000000000000012965966f32))]); + let result = instance.call( + "f32.div", + &[ + Value::F32((-1039406400000000000000.0f32)), + Value::F32((-0.000000000000000000000000012965966f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2181,31 +3290,64 @@ fn c252_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 412 fn c253_l412_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c253_l412_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((0.000000000000026831563f32)), Value::F32((31241038000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000008588563f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((0.000000000000026831563f32)), + Value::F32((31241038000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.0000000000000000000000000008588563f32)))) + ); result.map(|_| ()) } // Line 413 fn c254_l413_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c254_l413_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((1.2734247f32)), Value::F32((-692783700000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000000018381274f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((1.2734247f32)), + Value::F32((-692783700000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-0.0000000000000000000000000018381274f32)))) + ); result.map(|_| ()) } // Line 414 fn c255_l414_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c255_l414_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((0.00000000000000068988827f32)), Value::F32((0.000000000000000000000000000000000000003762676f32))]); - assert_eq!(result, Ok(Some(Value::F32((183350460000000000000000.0f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((0.00000000000000068988827f32)), + Value::F32((0.000000000000000000000000000000000000003762676f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((183350460000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 415 fn c256_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c256_l415_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((1819916200000000000000000000.0f32)), Value::F32((205067030000000000000000000.0f32))]); + let result = instance.call( + "f32.div", + &[ + Value::F32((1819916200000000000000000000.0f32)), + Value::F32((205067030000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((8.874739f32))))); result.map(|_| ()) } @@ -2245,15 +3387,34 @@ fn c260_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 420 fn c261_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c261_l420_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((-173388773324941200000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((-70026160475217470.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((2476057121342590000000000000000000000000000000000000000.0f64))))); + let result = instance.call( + "f64.div", + &[ + Value::F64( + (-173388773324941200000000000000000000000000000000000000000000000000000000.0f64), + ), + Value::F64((-70026160475217470.0f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (2476057121342590000000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } // Line 423 fn c262_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c262_l423_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((93506190.0f32)), Value::F32((0.0000000000000000000000000000000000028760885f32))]); + let result = instance.call( + "f32.div", + &[ + Value::F32((93506190.0f32)), + Value::F32((0.0000000000000000000000000000000000028760885f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2261,7 +3422,13 @@ fn c262_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 424 fn c263_l424_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c263_l424_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((-200575400000000000000000.0f32)), Value::F32((246697220.0f32))]); + let result = instance.call( + "f32.div", + &[ + Value::F32((-200575400000000000000000.0f32)), + Value::F32((246697220.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-813042800000000.0f32))))); result.map(|_| ()) } @@ -2269,24 +3436,51 @@ fn c263_l424_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 425 fn c264_l425_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c264_l425_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((384712200000.0f32)), Value::F32((-107037850000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000359417f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((384712200000.0f32)), + Value::F32((-107037850000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((-0.00000000000000000359417f32)))) + ); result.map(|_| ()) } // Line 426 fn c265_l426_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c265_l426_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((-4156665000000000000000000000000000.0f32)), Value::F32((-901.4192f32))]); - assert_eq!(result, Ok(Some(Value::F32((4611245300000000000000000000000.0f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((-4156665000000000000000000000000000.0f32)), + Value::F32((-901.4192f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((4611245300000000000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 427 fn c266_l427_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c266_l427_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((-6702387000000000000000000000.0f32)), Value::F32((-14000.255f32))]); - assert_eq!(result, Ok(Some(Value::F32((478733200000000000000000.0f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((-6702387000000000000000000000.0f32)), + Value::F32((-14000.255f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((478733200000000000000000.0f32)))) + ); result.map(|_| ()) } @@ -2325,8 +3519,17 @@ fn c270_l431_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 432 fn c271_l432_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c271_l432_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((4039956270017490000000000000000000000000000000000000000.0f64)), Value::F64((-47097881971884274000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000857778757955442f64))))); + let result = instance.call( + "f64.div", + &[ + Value::F64((4039956270017490000000000000000000000000000000000000000.0f64)), + Value::F64((-47097881971884274000000000000000000000000000000000000000000000000.0f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64((-0.0000000000857778757955442f64)))) + ); result.map(|_| ()) } @@ -2342,7 +3545,12 @@ fn c272_l435_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c273_l436_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c273_l436_action_invoke"); let result = instance.call("f64.div", &[Value::F64((-304261712294687660000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64)), Value::F64((-2655679232658824300000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((114570204320220420000000000000000000000000000000000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (114570204320220420000000000000000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -2358,7 +3566,12 @@ fn c274_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c275_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c275_l438_action_invoke"); let result = instance.call("f64.div", &[Value::F64((289260843556341600000000000000000000000000000000000000000000000000.0f64)), Value::F64((517194875837335500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000005592879146144478f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.0000000000000000000000000000000000000000000000000000000000000005592879146144478f64) + ))) + ); result.map(|_| ()) } @@ -2421,7 +3634,13 @@ fn c282_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 450 fn c283_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c283_l450_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((1038860800000000000000000000.0f32)), Value::F32((6211079500000.0f32))]); + let result = instance.call( + "f32.div", + &[ + Value::F32((1038860800000000000000000000.0f32)), + Value::F32((6211079500000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((167259300000000.0f32))))); result.map(|_| ()) } @@ -2429,7 +3648,13 @@ fn c283_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 451 fn c284_l451_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c284_l451_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((1869033000000000000000000000.0f32)), Value::F32((-112355730000000000000000000000000.0f32))]); + let result = instance.call( + "f32.div", + &[ + Value::F32((1869033000000000000000000000.0f32)), + Value::F32((-112355730000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((-0.00001663496f32))))); result.map(|_| ()) } @@ -2437,15 +3662,27 @@ fn c284_l451_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 452 fn c285_l452_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c285_l452_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((3290747200000000000000000.0f32)), Value::F32((0.9064788f32))]); - assert_eq!(result, Ok(Some(Value::F32((3630252700000000000000000.0f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((3290747200000000000000000.0f32)), + Value::F32((0.9064788f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32((3630252700000000000000000.0f32)))) + ); result.map(|_| ()) } // Line 453 fn c286_l453_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c286_l453_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((-908946.56f32)), Value::F32((-17034289000.0f32))]); + let result = instance.call( + "f32.div", + &[Value::F32((-908946.56f32)), Value::F32((-17034289000.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.000053359818f32))))); result.map(|_| ()) } @@ -2453,8 +3690,19 @@ fn c286_l453_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 454 fn c287_l454_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c287_l454_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((-0.00000000000024092477f32)), Value::F32((-89840810000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000026816852f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((-0.00000000000024092477f32)), + Value::F32((-89840810000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.0000000000000000000000000000026816852f32) + ))) + ); result.map(|_| ()) } @@ -2501,23 +3749,47 @@ fn c292_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 462 fn c293_l462_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c293_l462_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((0.00000000000000001046256872449641f64)), Value::F64((1.8150892711657447f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.000000000000000005764217160391678f64))))); + let result = instance.call( + "f64.div", + &[ + Value::F64((0.00000000000000001046256872449641f64)), + Value::F64((1.8150892711657447f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64((0.000000000000000005764217160391678f64)))) + ); result.map(|_| ()) } // Line 463 fn c294_l463_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c294_l463_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((0.00000000000000000000000000000022038268106596436f64)), Value::F64((-0.0000000000002859803943943555f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000007706216418530616f64))))); + let result = instance.call( + "f64.div", + &[ + Value::F64((0.00000000000000000000000000000022038268106596436f64)), + Value::F64((-0.0000000000002859803943943555f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64((-0.0000000000000000007706216418530616f64)))) + ); result.map(|_| ()) } // Line 464 fn c295_l464_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c295_l464_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((0.0000000000007596539988437179f64)), Value::F64((0.00000000000000000000000000000000021055358831337124f64))]); + let result = instance.call( + "f64.div", + &[ + Value::F64((0.0000000000007596539988437179f64)), + Value::F64((0.00000000000000000000000000000000021055358831337124f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((3607889112357986600000.0f64))))); result.map(|_| ()) } @@ -2525,7 +3797,13 @@ fn c295_l464_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 465 fn c296_l465_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c296_l465_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((1120696114500866900000000000.0f64)), Value::F64((159713233802866500000000000000.0f64))]); + let result = instance.call( + "f64.div", + &[ + Value::F64((1120696114500866900000000000.0f64)), + Value::F64((159713233802866500000000000000.0f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.007016927074960728f64))))); result.map(|_| ()) } @@ -2533,15 +3811,32 @@ fn c296_l465_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 466 fn c297_l466_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c297_l466_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((0.0006342142502301953f64)), Value::F64((-6391950865520085.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000009922076429769178f64))))); + let result = instance.call( + "f64.div", + &[ + Value::F64((0.0006342142502301953f64)), + Value::F64((-6391950865520085.0f64)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (-0.00000000000000000009922076429769178f64) + ))) + ); result.map(|_| ()) } // Line 469 fn c298_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c298_l469_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((0.000000000000000000000000000000000000011754944f32)), Value::F32((0.000000000000000000000000000000000000011754942f32))]); + let result = instance.call( + "f32.div", + &[ + Value::F32((0.000000000000000000000000000000000000011754944f32)), + Value::F32((0.000000000000000000000000000000000000011754942f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0000001f32))))); result.map(|_| ()) } @@ -2549,7 +3844,13 @@ fn c298_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 470 fn c299_l470_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c299_l470_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((0.000000000000000000000000000000000000011754942f32)), Value::F32((0.000000000000000000000000000000000000011754944f32))]); + let result = instance.call( + "f32.div", + &[ + Value::F32((0.000000000000000000000000000000000000011754942f32)), + Value::F32((0.000000000000000000000000000000000000011754944f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.9999999f32))))); result.map(|_| ()) } @@ -2573,7 +3874,13 @@ fn c301_l472_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 475 fn c302_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c302_l475_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((0.00000023841856f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); + let result = instance.call( + "f32.div", + &[ + Value::F32((0.00000023841856f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32((0.0f32))))); result.map(|_| ()) } @@ -2581,8 +3888,19 @@ fn c302_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 476 fn c303_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c303_l476_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((0.00000023841858f32)), Value::F32((340282350000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((0.00000023841858f32)), + Value::F32((340282350000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000001f32) + ))) + ); result.map(|_| ()) } @@ -2605,7 +3923,13 @@ fn c305_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 481 fn c306_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c306_l481_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000002938736f32))]); + let result = instance.call( + "f32.div", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000002938736f32)), + ], + ); assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY)))); result.map(|_| ()) } @@ -2613,8 +3937,19 @@ fn c306_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 482 fn c307_l482_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c307_l482_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((1.0f32)), Value::F32((0.000000000000000000000000000000000000002938737f32))]); - assert_eq!(result, Ok(Some(Value::F32((340282200000000000000000000000000000000.0f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((1.0f32)), + Value::F32((0.000000000000000000000000000000000000002938737f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (340282200000000000000000000000000000000.0f32) + ))) + ); result.map(|_| ()) } @@ -2637,16 +3972,38 @@ fn c309_l484_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 487 fn c310_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c310_l487_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((1.0f32)), Value::F32((85070600000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((1.0f32)), + Value::F32((85070600000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754942f32) + ))) + ); result.map(|_| ()) } // Line 488 fn c311_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c311_l488_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((1.0f32)), Value::F32((85070590000000000000000000000000000000.0f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32))))); + let result = instance.call( + "f32.div", + &[ + Value::F32((1.0f32)), + Value::F32((85070590000000000000000000000000000000.0f32)), + ], + ); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000011754944f32) + ))) + ); result.map(|_| ()) } @@ -2717,7 +4074,10 @@ fn c319_l505_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 508 fn c320_l508_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c320_l508_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((1.0000001f32)), Value::F32((0.99999994f32))]); + let result = instance.call( + "f32.div", + &[Value::F32((1.0000001f32)), Value::F32((0.99999994f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0000002f32))))); result.map(|_| ()) } @@ -2725,7 +4085,10 @@ fn c320_l508_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 509 fn c321_l509_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c321_l509_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((0.99999994f32)), Value::F32((1.0000001f32))]); + let result = instance.call( + "f32.div", + &[Value::F32((0.99999994f32)), Value::F32((1.0000001f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.9999998f32))))); result.map(|_| ()) } @@ -2733,7 +4096,10 @@ fn c321_l509_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 510 fn c322_l510_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c322_l510_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((1.0f32)), Value::F32((0.99999994f32))]); + let result = instance.call( + "f32.div", + &[Value::F32((1.0f32)), Value::F32((0.99999994f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1.0000001f32))))); result.map(|_| ()) } @@ -2741,7 +4107,10 @@ fn c322_l510_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 511 fn c323_l511_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c323_l511_action_invoke"); - let result = instance.call("f32.div", &[Value::F32((1.0f32)), Value::F32((1.0000001f32))]); + let result = instance.call( + "f32.div", + &[Value::F32((1.0f32)), Value::F32((1.0000001f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.9999999f32))))); result.map(|_| ()) } @@ -2749,7 +4118,13 @@ fn c323_l511_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 512 fn c324_l512_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c324_l512_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((1.0000000000000002f64)), Value::F64((0.9999999999999999f64))]); + let result = instance.call( + "f64.div", + &[ + Value::F64((1.0000000000000002f64)), + Value::F64((0.9999999999999999f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0000000000000004f64))))); result.map(|_| ()) } @@ -2757,7 +4132,13 @@ fn c324_l512_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 513 fn c325_l513_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c325_l513_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((0.9999999999999999f64)), Value::F64((1.0000000000000002f64))]); + let result = instance.call( + "f64.div", + &[ + Value::F64((0.9999999999999999f64)), + Value::F64((1.0000000000000002f64)), + ], + ); assert_eq!(result, Ok(Some(Value::F64((0.9999999999999997f64))))); result.map(|_| ()) } @@ -2765,7 +4146,10 @@ fn c325_l513_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 514 fn c326_l514_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c326_l514_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((1.0f64)), Value::F64((0.9999999999999999f64))]); + let result = instance.call( + "f64.div", + &[Value::F64((1.0f64)), Value::F64((0.9999999999999999f64))], + ); assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64))))); result.map(|_| ()) } @@ -2773,7 +4157,10 @@ fn c326_l514_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 515 fn c327_l515_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c327_l515_action_invoke"); - let result = instance.call("f64.div", &[Value::F64((1.0f64)), Value::F64((1.0000000000000002f64))]); + let result = instance.call( + "f64.div", + &[Value::F64((1.0f64)), Value::F64((1.0000000000000002f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.9999999999999998f64))))); result.map(|_| ()) } @@ -2813,8 +4200,18 @@ fn c331_l522_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 525 fn c332_l525_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c332_l525_action_invoke"); - let result = instance.call("f64.sqrt", &[Value::F64((0.00000000000000000000000000000000000000000000000004316357580352844f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000020775845543209175f64))))); + let result = instance.call( + "f64.sqrt", + &[Value::F64( + (0.00000000000000000000000000000000000000000000000004316357580352844f64), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.00000000000000000000000020775845543209175f64) + ))) + ); result.map(|_| ()) } @@ -2822,7 +4219,12 @@ fn c332_l525_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c333_l526_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c333_l526_action_invoke"); let result = instance.call("f64.sqrt", &[Value::F64((676253300479648500000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((822346216918183800000000000000000000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (822346216918183800000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } @@ -2830,14 +4232,22 @@ fn c333_l526_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c334_l527_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c334_l527_action_invoke"); let result = instance.call("f64.sqrt", &[Value::F64((17485296624861996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((4181542373916829400000000000000000000000000000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (4181542373916829400000000000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } // Line 528 fn c335_l528_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c335_l528_action_invoke"); - let result = instance.call("f64.sqrt", &[Value::F64((0.000000000009593720960603523f64))]); + let result = instance.call( + "f64.sqrt", + &[Value::F64((0.000000000009593720960603523f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.0000030973732355987585f64))))); result.map(|_| ()) } @@ -2846,7 +4256,12 @@ fn c335_l528_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c336_l529_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c336_l529_action_invoke"); let result = instance.call("f64.sqrt", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006348452898717835f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000002519613640762773f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.00000000000000000000000000000000000000000000000000000002519613640762773f64) + ))) + ); result.map(|_| ()) } @@ -2869,7 +4284,10 @@ fn c338_l536_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 537 fn c339_l537_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c339_l537_action_invoke"); - let result = instance.call("f32.sqrt", &[Value::F32((2345875800000000000000000000000.0f32))]); + let result = instance.call( + "f32.sqrt", + &[Value::F32((2345875800000000000000000000000.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((1531625200000000.0f32))))); result.map(|_| ()) } @@ -2885,7 +4303,10 @@ fn c340_l538_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 539 fn c341_l539_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c341_l539_action_invoke"); - let result = instance.call("f32.sqrt", &[Value::F32((0.00000000000000000000051371026f32))]); + let result = instance.call( + "f32.sqrt", + &[Value::F32((0.00000000000000000000051371026f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.000000000022665177f32))))); result.map(|_| ()) } @@ -2918,14 +4339,22 @@ fn c344_l542_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c345_l543_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c345_l543_action_invoke"); let result = instance.call("f64.sqrt", &[Value::F64((147706699783365580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((12153464517715332000000000000000000000000000000000000000000.0f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (12153464517715332000000000000000000000000000000000000000000.0f64) + ))) + ); result.map(|_| ()) } // Line 544 fn c346_l544_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c346_l544_action_invoke"); - let result = instance.call("f64.sqrt", &[Value::F64((48800457180027890000000000000000.0f64))]); + let result = instance.call( + "f64.sqrt", + &[Value::F64((48800457180027890000000000000000.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((6985732401117859.0f64))))); result.map(|_| ()) } @@ -2949,7 +4378,10 @@ fn c348_l548_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 549 fn c349_l549_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c349_l549_action_invoke"); - let result = instance.call("f32.sqrt", &[Value::F32((0.00000000000000000000000000000000010471305f32))]); + let result = instance.call( + "f32.sqrt", + &[Value::F32((0.00000000000000000000000000000000010471305f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000000000000001023294f32))))); result.map(|_| ()) } @@ -2965,16 +4397,32 @@ fn c350_l550_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 551 fn c351_l551_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c351_l551_action_invoke"); - let result = instance.call("f32.sqrt", &[Value::F32((0.00000000000000000000000000000000000089607535f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000009466126f32))))); + let result = instance.call( + "f32.sqrt", + &[Value::F32( + (0.00000000000000000000000000000000000089607535f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.0000000000000000009466126f32)))) + ); result.map(|_| ()) } // Line 552 fn c352_l552_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c352_l552_action_invoke"); - let result = instance.call("f32.sqrt", &[Value::F32((0.0000000000000000000000000000000000001687712f32))]); - assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000041081773f32))))); + let result = instance.call( + "f32.sqrt", + &[Value::F32( + (0.0000000000000000000000000000000000001687712f32), + )], + ); + assert_eq!( + result, + Ok(Some(Value::F32((0.00000000000000000041081773f32)))) + ); result.map(|_| ()) } @@ -3006,7 +4454,12 @@ fn c355_l555_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c356_l556_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c356_l556_action_invoke"); let result = instance.call("f64.sqrt", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000002822766928951239f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000005312971794533864f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.0000000000000000000000000000000000005312971794533864f64) + ))) + ); result.map(|_| ()) } @@ -3021,7 +4474,10 @@ fn c357_l557_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 560 fn c358_l560_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c358_l560_action_invoke"); - let result = instance.call("f32.sqrt", &[Value::F32((464023420000000000000000000000000000.0f32))]); + let result = instance.call( + "f32.sqrt", + &[Value::F32((464023420000000000000000000000000000.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((681192700000000000.0f32))))); result.map(|_| ()) } @@ -3045,7 +4501,10 @@ fn c360_l562_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 563 fn c361_l563_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c361_l563_action_invoke"); - let result = instance.call("f32.sqrt", &[Value::F32((0.000000000000000000000000009549605f32))]); + let result = instance.call( + "f32.sqrt", + &[Value::F32((0.000000000000000000000000009549605f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.00000000000009772208f32))))); result.map(|_| ()) } @@ -3053,7 +4512,10 @@ fn c361_l563_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 564 fn c362_l564_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c362_l564_action_invoke"); - let result = instance.call("f32.sqrt", &[Value::F32((0.000000000000000000000000000068856485f32))]); + let result = instance.call( + "f32.sqrt", + &[Value::F32((0.000000000000000000000000000068856485f32))], + ); assert_eq!(result, Ok(Some(Value::F32((0.000000000000008297981f32))))); result.map(|_| ()) } @@ -3070,7 +4532,12 @@ fn c363_l565_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c364_l566_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c364_l566_action_invoke"); let result = instance.call("f64.sqrt", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029262574743429683f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000005409489323718985f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.0000000000000000000000000000000000000000000000000000000005409489323718985f64) + ))) + ); result.map(|_| ()) } @@ -3085,7 +4552,10 @@ fn c365_l567_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 568 fn c366_l568_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c366_l568_action_invoke"); - let result = instance.call("f64.sqrt", &[Value::F64((0.000000000000035498432023945234f64))]); + let result = instance.call( + "f64.sqrt", + &[Value::F64((0.000000000000035498432023945234f64))], + ); assert_eq!(result, Ok(Some(Value::F64((0.00000018841027579180822f64))))); result.map(|_| ()) } @@ -3100,19 +4570,25 @@ fn c367_l569_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 572 fn c368_l572_assert_return_canonical_nan(instance: &mut Instance) { - println!("Executing function {}", "c368_l572_assert_return_canonical_nan"); + println!( + "Executing function {}", + "c368_l572_assert_return_canonical_nan" + ); let result = instance.call("f64.sqrt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015535152663257847f64))]).unwrap().expect("Missing result in c368_l572_assert_return_canonical_nan"); assert!(match result { Value::F32(fp) => fp.is_quiet_nan(), Value::F64(fp) => fp.is_quiet_nan(), - _ => unimplemented!() + _ => unimplemented!(), }) } // Line 573 fn c369_l573_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c369_l573_action_invoke"); - let result = instance.call("f64.sqrt", &[Value::F64((18763296348029700000000000000000.0f64))]); + let result = instance.call( + "f64.sqrt", + &[Value::F64((18763296348029700000000000000000.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((4331662076851067.0f64))))); result.map(|_| ()) } @@ -3129,7 +4605,12 @@ fn c370_l574_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c371_l575_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c371_l575_action_invoke"); let result = instance.call("f64.sqrt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000015613859952920445f64))]); - assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000039514377070783294f64))))); + assert_eq!( + result, + Ok(Some(Value::F64( + (0.0000000000000000000000000000000000000000039514377070783294f64) + ))) + ); result.map(|_| ()) } @@ -3210,12 +4691,15 @@ fn c381_l592_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c381_l592_action_invoke"); let result = instance.call("f32.abs", &[Value::F32(f32::from_bits(2139156962))]); let expected = f32::from_bits(2139156962); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3224,40 +4708,55 @@ fn c382_l593_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c382_l593_action_invoke"); let result = instance.call("f32.abs", &[Value::F32(f32::from_bits(4286640610))]); let expected = f32::from_bits(2139156962); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 594 fn c383_l594_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c383_l594_action_invoke"); - let result = instance.call("f64.abs", &[Value::F64(f64::from_bits(9218868441285556843))]); + let result = instance.call( + "f64.abs", + &[Value::F64(f64::from_bits(9218868441285556843))], + ); let expected = f64::from_bits(9218868441285556843); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 595 fn c384_l595_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c384_l595_action_invoke"); - let result = instance.call("f64.abs", &[Value::F64(f64::from_bits(18442240478140332651))]); + let result = instance.call( + "f64.abs", + &[Value::F64(f64::from_bits(18442240478140332651))], + ); let expected = f64::from_bits(9218868441285556843); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3266,12 +4765,15 @@ fn c385_l597_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c385_l597_action_invoke"); let result = instance.call("f32.neg", &[Value::F32(f32::from_bits(2139156962))]); let expected = f32::from_bits(4286640610); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3280,152 +4782,239 @@ fn c386_l598_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c386_l598_action_invoke"); let result = instance.call("f32.neg", &[Value::F32(f32::from_bits(4286640610))]); let expected = f32::from_bits(2139156962); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 599 fn c387_l599_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c387_l599_action_invoke"); - let result = instance.call("f64.neg", &[Value::F64(f64::from_bits(9218868441285556843))]); + let result = instance.call( + "f64.neg", + &[Value::F64(f64::from_bits(9218868441285556843))], + ); let expected = f64::from_bits(18442240478140332651); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 600 fn c388_l600_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c388_l600_action_invoke"); - let result = instance.call("f64.neg", &[Value::F64(f64::from_bits(18442240478140332651))]); + let result = instance.call( + "f64.neg", + &[Value::F64(f64::from_bits(18442240478140332651))], + ); let expected = f64::from_bits(9218868441285556843); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 602 fn c389_l602_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c389_l602_action_invoke"); - let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(2139156962)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.copysign", + &[ + Value::F32(f32::from_bits(2139156962)), + Value::F32(f32::from_bits(2143289344)), + ], + ); let expected = f32::from_bits(2139156962); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 603 fn c390_l603_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c390_l603_action_invoke"); - let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(2139156962)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "f32.copysign", + &[ + Value::F32(f32::from_bits(2139156962)), + Value::F32(f32::from_bits(4290772992)), + ], + ); let expected = f32::from_bits(4286640610); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 604 fn c391_l604_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c391_l604_action_invoke"); - let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(4286640610)), Value::F32(f32::from_bits(2143289344))]); + let result = instance.call( + "f32.copysign", + &[ + Value::F32(f32::from_bits(4286640610)), + Value::F32(f32::from_bits(2143289344)), + ], + ); let expected = f32::from_bits(2139156962); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 605 fn c392_l605_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c392_l605_action_invoke"); - let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(4286640610)), Value::F32(f32::from_bits(4290772992))]); + let result = instance.call( + "f32.copysign", + &[ + Value::F32(f32::from_bits(4286640610)), + Value::F32(f32::from_bits(4290772992)), + ], + ); let expected = f32::from_bits(4286640610); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 606 fn c393_l606_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c393_l606_action_invoke"); - let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(9218868441285556843)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.copysign", + &[ + Value::F64(f64::from_bits(9218868441285556843)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); let expected = f64::from_bits(9218868441285556843); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 607 fn c394_l607_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c394_l607_action_invoke"); - let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(9218868441285556843)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "f64.copysign", + &[ + Value::F64(f64::from_bits(9218868441285556843)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); let expected = f64::from_bits(18442240478140332651); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 608 fn c395_l608_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c395_l608_action_invoke"); - let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(18442240478140332651)), Value::F64(f64::from_bits(9221120237041090560))]); + let result = instance.call( + "f64.copysign", + &[ + Value::F64(f64::from_bits(18442240478140332651)), + Value::F64(f64::from_bits(9221120237041090560)), + ], + ); let expected = f64::from_bits(9218868441285556843); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 609 fn c396_l609_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c396_l609_action_invoke"); - let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(18442240478140332651)), Value::F64(f64::from_bits(18444492273895866368))]); + let result = instance.call( + "f64.copysign", + &[ + Value::F64(f64::from_bits(18442240478140332651)), + Value::F64(f64::from_bits(18444492273895866368)), + ], + ); let expected = f64::from_bits(18442240478140332651); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -3696,8 +5285,14 @@ fn c429_l662_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 663 fn c430_l663_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c430_l663_action_invoke"); - let result = instance.call("f64.nearest", &[Value::F64((81129638414606670000000000000000.0f64))]); - assert_eq!(result, Ok(Some(Value::F64((81129638414606670000000000000000.0f64))))); + let result = instance.call( + "f64.nearest", + &[Value::F64((81129638414606670000000000000000.0f64))], + ); + assert_eq!( + result, + Ok(Some(Value::F64((81129638414606670000000000000000.0f64)))) + ); result.map(|_| ()) } diff --git a/lib/runtime/tests/spectests/forward.rs b/lib/runtime/tests/spectests/forward.rs index 3328e83ab..a7f1cc842 100644 --- a/lib/runtime/tests/spectests/forward.rs +++ b/lib/runtime/tests/spectests/forward.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { @@ -50,8 +46,11 @@ fn create_module_1() -> Box { (export \"odd\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { diff --git a/lib/runtime/tests/spectests/func.rs b/lib/runtime/tests/spectests/func.rs index 4cd5189cd..40746aded 100644 --- a/lib/runtime/tests/spectests/func.rs +++ b/lib/runtime/tests/spectests/func.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -331,8 +327,11 @@ fn create_module_1() -> Box { (export \"init-local-f64\" (func 78))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -367,7 +366,14 @@ fn c3_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 175 fn c4_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c4_l175_action_invoke"); - let result = instance.call("type-use-4", &[Value::I32(1 as i32), Value::F64((1.0f64)), Value::I32(1 as i32)]); + let result = instance.call( + "type-use-4", + &[ + Value::I32(1 as i32), + Value::F64((1.0f64)), + Value::I32(1 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -391,7 +397,14 @@ fn c6_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 181 fn c7_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c7_l181_action_invoke"); - let result = instance.call("type-use-7", &[Value::I32(1 as i32), Value::F64((1.0f64)), Value::I32(1 as i32)]); + let result = instance.call( + "type-use-7", + &[ + Value::I32(1 as i32), + Value::F64((1.0f64)), + Value::I32(1 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -471,7 +484,10 @@ fn c16_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 196 fn c17_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c17_l196_action_invoke"); - let result = instance.call("param-first-i32", &[Value::I32(2 as i32), Value::I32(3 as i32)]); + let result = instance.call( + "param-first-i32", + &[Value::I32(2 as i32), Value::I32(3 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); result.map(|_| ()) } @@ -479,7 +495,10 @@ fn c17_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 199 fn c18_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c18_l199_action_invoke"); - let result = instance.call("param-first-i64", &[Value::I64(2 as i64), Value::I64(3 as i64)]); + let result = instance.call( + "param-first-i64", + &[Value::I64(2 as i64), Value::I64(3 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); result.map(|_| ()) } @@ -487,7 +506,10 @@ fn c18_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 202 fn c19_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c19_l202_action_invoke"); - let result = instance.call("param-first-f32", &[Value::F32((2.0f32)), Value::F32((3.0f32))]); + let result = instance.call( + "param-first-f32", + &[Value::F32((2.0f32)), Value::F32((3.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((2.0f32))))); result.map(|_| ()) } @@ -495,7 +517,10 @@ fn c19_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 205 fn c20_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c20_l205_action_invoke"); - let result = instance.call("param-first-f64", &[Value::F64((2.0f64)), Value::F64((3.0f64))]); + let result = instance.call( + "param-first-f64", + &[Value::F64((2.0f64)), Value::F64((3.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((2.0f64))))); result.map(|_| ()) } @@ -503,7 +528,10 @@ fn c20_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 208 fn c21_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c21_l208_action_invoke"); - let result = instance.call("param-second-i32", &[Value::I32(2 as i32), Value::I32(3 as i32)]); + let result = instance.call( + "param-second-i32", + &[Value::I32(2 as i32), Value::I32(3 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); result.map(|_| ()) } @@ -511,7 +539,10 @@ fn c21_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 211 fn c22_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c22_l211_action_invoke"); - let result = instance.call("param-second-i64", &[Value::I64(2 as i64), Value::I64(3 as i64)]); + let result = instance.call( + "param-second-i64", + &[Value::I64(2 as i64), Value::I64(3 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(3 as i64)))); result.map(|_| ()) } @@ -519,7 +550,10 @@ fn c22_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 214 fn c23_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c23_l214_action_invoke"); - let result = instance.call("param-second-f32", &[Value::F32((2.0f32)), Value::F32((3.0f32))]); + let result = instance.call( + "param-second-f32", + &[Value::F32((2.0f32)), Value::F32((3.0f32))], + ); assert_eq!(result, Ok(Some(Value::F32((3.0f32))))); result.map(|_| ()) } @@ -527,7 +561,10 @@ fn c23_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 217 fn c24_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c24_l217_action_invoke"); - let result = instance.call("param-second-f64", &[Value::F64((2.0f64)), Value::F64((3.0f64))]); + let result = instance.call( + "param-second-f64", + &[Value::F64((2.0f64)), Value::F64((3.0f64))], + ); assert_eq!(result, Ok(Some(Value::F64((3.0f64))))); result.map(|_| ()) } @@ -535,7 +572,17 @@ fn c24_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 221 fn c25_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c25_l221_action_invoke"); - let result = instance.call("param-mixed", &[Value::F32((1.0f32)), Value::I32(2 as i32), Value::I64(3 as i64), Value::I32(4 as i32), Value::F64((5.5f64)), Value::I32(6 as i32)]); + let result = instance.call( + "param-mixed", + &[ + Value::F32((1.0f32)), + Value::I32(2 as i32), + Value::I64(3 as i64), + Value::I32(4 as i32), + Value::F64((5.5f64)), + Value::I32(6 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::F64((5.5f64))))); result.map(|_| ()) } @@ -987,8 +1034,11 @@ fn create_module_2() -> Box { drop)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -999,7 +1049,11 @@ fn start_module_2(instance: &mut Instance) { // Line 303 #[test] fn c71_l303_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 1, 127, 0, 96, 0, 1, 124, 3, 5, 4, 1, 0, 1, 2, 10, 31, 4, 11, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 2, 0, 11, 11, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 1, 127, 0, 96, 0, 1, 124, 3, 5, 4, 1, 0, 1, 2, + 10, 31, 4, 11, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 2, 0, 11, 11, 0, 68, 0, 0, 0, 0, 0, 0, + 240, 63, 11, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1093,8 +1147,11 @@ fn create_module_3() -> Box { (elem (;0;) (i32.const 0) 4 2 1 4 0 5 6)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -1137,87 +1194,178 @@ fn c76_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 387 #[test] fn c77_l387_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, + 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, + 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 394 #[test] fn c78_l394_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, + 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 401 #[test] fn c79_l401_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, + 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, + 115, 105, 103, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 408 #[test] fn c80_l408_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, + 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 415 #[test] fn c81_l415_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, + 115, 105, 103, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 422 #[test] fn c82_l422_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, + 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, + 116, 32, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 429 #[test] fn c83_l429_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 41, 41, 40, 102, 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 41, 41, 40, 102, + 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, + 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, + 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 436 #[test] fn c84_l436_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, + 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, + 111, 110, 115, 116, 32, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 443 #[test] fn c85_l443_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, + 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, + 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 450 #[test] fn c86_l450_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 117, 110, 114, 101, 97, 99, 104, 97, 98, 108, 101, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, + 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, + 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, + 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 117, 110, 114, 101, 97, 99, 104, 97, 98, + 108, 101, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 461 #[test] fn c87_l461_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 8, 1, 6, 1, 1, 127, 32, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 8, 1, 6, 1, 1, 127, + 32, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1225,7 +1373,10 @@ fn c87_l461_assert_invalid() { // Line 465 #[test] fn c88_l465_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 1, 1, 125, 32, 0, 69, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 1, 1, 125, 32, 0, + 69, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1233,7 +1384,10 @@ fn c88_l465_assert_invalid() { // Line 469 #[test] fn c89_l469_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 2, 1, 124, 1, 126, 32, 1, 154, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 2, 1, 124, 1, + 126, 32, 1, 154, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1241,7 +1395,10 @@ fn c89_l469_assert_invalid() { // Line 477 #[test] fn c90_l477_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 126, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 126, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, + 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1249,7 +1406,10 @@ fn c90_l477_assert_invalid() { // Line 481 #[test] fn c91_l481_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 0, 69, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 0, 69, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1257,7 +1417,10 @@ fn c91_l481_assert_invalid() { // Line 485 #[test] fn c92_l485_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 1, 154, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, + 1, 154, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1265,7 +1428,10 @@ fn c92_l485_assert_invalid() { // Line 493 #[test] fn c93_l493_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 0, 2, 127, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 0, 2, 127, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 0, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1273,7 +1439,10 @@ fn c93_l493_assert_invalid() { // Line 497 #[test] fn c94_l497_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 0, 2, 127, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 0, 2, 127, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 0, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1281,7 +1450,9 @@ fn c94_l497_assert_invalid() { // Line 506 #[test] fn c95_l506_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 4, 1, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1289,7 +1460,9 @@ fn c95_l506_assert_invalid() { // Line 510 #[test] fn c96_l510_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 4, 1, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1297,7 +1470,9 @@ fn c96_l510_assert_invalid() { // Line 514 #[test] fn c97_l514_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 4, 1, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1305,7 +1480,9 @@ fn c97_l514_assert_invalid() { // Line 518 #[test] fn c98_l518_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 4, 1, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1313,7 +1490,9 @@ fn c98_l518_assert_invalid() { // Line 523 #[test] fn c99_l523_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1321,7 +1500,9 @@ fn c99_l523_assert_invalid() { // Line 529 #[test] fn c100_l529_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 65, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 65, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1329,7 +1510,10 @@ fn c100_l529_assert_invalid() { // Line 535 #[test] fn c101_l535_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 67, 0, 0, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 67, 0, 0, + 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1337,7 +1521,9 @@ fn c101_l535_assert_invalid() { // Line 542 #[test] fn c102_l542_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 15, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 15, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1345,7 +1531,9 @@ fn c102_l542_assert_invalid() { // Line 548 #[test] fn c103_l548_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 6, 1, 4, 0, 1, 15, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 6, 1, 4, 0, 1, 15, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1353,7 +1541,10 @@ fn c103_l548_assert_invalid() { // Line 554 #[test] fn c104_l554_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 15, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 15, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1361,7 +1552,10 @@ fn c104_l554_assert_invalid() { // Line 561 #[test] fn c105_l561_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 15, 65, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 15, 65, 1, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1369,7 +1563,10 @@ fn c105_l561_assert_invalid() { // Line 567 #[test] fn c106_l567_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 1, 15, 65, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 1, 15, 65, + 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1377,7 +1574,10 @@ fn c106_l567_assert_invalid() { // Line 573 #[test] fn c107_l573_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 66, 1, 15, 65, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 66, 1, 15, + 65, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1385,7 +1585,10 @@ fn c107_l573_assert_invalid() { // Line 579 #[test] fn c108_l579_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 66, 1, 15, 65, 1, 15, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 66, 1, + 15, 65, 1, 15, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1393,7 +1596,9 @@ fn c108_l579_assert_invalid() { // Line 586 #[test] fn c109_l586_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 6, 1, 4, 0, 12, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 6, 1, 4, 0, 12, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1401,7 +1606,10 @@ fn c109_l586_assert_invalid() { // Line 592 #[test] fn c110_l592_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 67, 0, 0, 0, 0, 12, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 67, 0, 0, + 0, 0, 12, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1409,7 +1617,10 @@ fn c110_l592_assert_invalid() { // Line 598 #[test] fn c111_l598_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 12, 0, 65, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 12, 0, 65, + 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1417,7 +1628,10 @@ fn c111_l598_assert_invalid() { // Line 604 #[test] fn c112_l604_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 66, 1, 12, 0, 65, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 66, 1, + 12, 0, 65, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1425,7 +1639,10 @@ fn c112_l604_assert_invalid() { // Line 610 #[test] fn c113_l610_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 1, 12, 0, 65, 1, 12, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 1, + 12, 0, 65, 1, 12, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1433,7 +1650,10 @@ fn c113_l610_assert_invalid() { // Line 617 #[test] fn c114_l617_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 12, 1, 11, 65, 1, 12, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, + 12, 1, 11, 65, 1, 12, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1441,7 +1661,10 @@ fn c114_l617_assert_invalid() { // Line 623 #[test] fn c115_l623_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 64, 1, 12, 1, 11, 65, 1, 12, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 64, + 1, 12, 1, 11, 65, 1, 12, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1449,7 +1672,10 @@ fn c115_l623_assert_invalid() { // Line 629 #[test] fn c116_l629_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 66, 1, 12, 1, 11, 65, 1, 12, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, + 66, 1, 12, 1, 11, 65, 1, 12, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1457,49 +1683,87 @@ fn c116_l629_assert_invalid() { // Line 639 #[test] fn c117_l639_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 110, 111, 112, 41, 32, 40, 108, 111, 99, 97, 108, 32, 105, 51, 50, 41, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 110, 111, 112, 41, 32, 40, 108, 111, 99, 97, 108, 32, 105, + 51, 50, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 643 #[test] fn c118_l643_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 110, 111, 112, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 110, 111, 112, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, + 51, 50, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 647 #[test] fn c119_l647_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 110, 111, 112, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 110, 111, 112, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, + 105, 51, 50, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 651 #[test] fn c120_l651_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 108, 111, 99, 97, 108, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 108, 111, 99, 97, 108, 32, 105, 51, 50, 41, 32, 40, 112, 97, + 114, 97, 109, 32, 105, 51, 50, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 655 #[test] fn c121_l655_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 108, 111, 99, 97, 108, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 103, 101, 116, 95, 108, 111, 99, 97, 108, 32, 48, 41, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 108, 111, 99, 97, 108, 32, 105, 51, 50, 41, 32, 40, 114, + 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 103, 101, 116, 95, 108, 111, 99, 97, + 108, 32, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 659 #[test] fn c122_l659_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 103, 101, 116, 95, 108, 111, 99, 97, 108, 32, 48, 41, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, + 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 103, 101, 116, 95, 108, 111, 99, 97, + 108, 32, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } #[test] diff --git a/lib/runtime/tests/spectests/func_ptrs.rs b/lib/runtime/tests/spectests/func_ptrs.rs index d205d8914..ad33d5afd 100644 --- a/lib/runtime/tests/spectests/func_ptrs.rs +++ b/lib/runtime/tests/spectests/func_ptrs.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { @@ -50,8 +46,11 @@ fn create_module_1() -> Box { (export \"four\" (func 6))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -87,7 +86,7 @@ fn c3_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c4_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c4_l30_action_invoke"); let result = instance.call("four", &[Value::I32(83 as i32)]); - + result.map(|_| ()) } @@ -102,7 +101,10 @@ fn c5_l32_assert_invalid() { // Line 33 #[test] fn c6_l33_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 9, 7, 1, 0, 65, 0, 11, 1, 0, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 9, 7, 1, 0, 65, 0, 11, 1, 0, + 10, 4, 1, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -110,7 +112,9 @@ fn c6_l33_assert_invalid() { // Line 36 #[test] fn c7_l36_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 6, 1, 0, 66, 0, 11, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 6, 1, 0, 66, 0, 11, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -118,7 +122,9 @@ fn c7_l36_assert_invalid() { // Line 40 #[test] fn c8_l40_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 7, 1, 0, 65, 0, 104, 11, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 7, 1, 0, 65, 0, 104, 11, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -126,7 +132,9 @@ fn c8_l40_assert_invalid() { // Line 44 #[test] fn c9_l44_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 5, 1, 0, 1, 11, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 5, 1, 0, 1, 11, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -142,7 +150,10 @@ fn c10_l48_assert_invalid() { // Line 49 #[test] fn c11_l49_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 2, 22, 1, 8, 115, 112, 101, 99, 116, 101, 115, 116, 9, 112, 114, 105, 110, 116, 95, 105, 51, 50, 0, 43]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 2, 22, 1, 8, 115, 112, 101, 99, 116, 101, 115, 116, 9, 112, + 114, 105, 110, 116, 95, 105, 51, 50, 0, 43, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -186,8 +197,11 @@ fn create_module_2() -> Box { (elem (;0;) (i32.const 0) 0 1 2 3 4 0 2)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -255,14 +269,14 @@ fn c19_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c20_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c20_l78_action_invoke"); let result = instance.call("callt", &[Value::I32(7 as i32)]); - + result.map(|_| ()) } #[test] fn c20_l78_assert_trap() { let mut instance = create_module_2(); - let result = c20_l78_action_invoke(&mut*instance); + let result = c20_l78_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -270,14 +284,14 @@ fn c20_l78_assert_trap() { fn c21_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c21_l79_action_invoke"); let result = instance.call("callt", &[Value::I32(100 as i32)]); - + result.map(|_| ()) } #[test] fn c21_l79_assert_trap() { let mut instance = create_module_2(); - let result = c21_l79_action_invoke(&mut*instance); + let result = c21_l79_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -285,14 +299,14 @@ fn c21_l79_assert_trap() { fn c22_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c22_l80_action_invoke"); let result = instance.call("callt", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c22_l80_assert_trap() { let mut instance = create_module_2(); - let result = c22_l80_action_invoke(&mut*instance); + let result = c22_l80_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -356,14 +370,14 @@ fn c29_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c30_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c30_l89_action_invoke"); let result = instance.call("callu", &[Value::I32(7 as i32)]); - + result.map(|_| ()) } #[test] fn c30_l89_assert_trap() { let mut instance = create_module_2(); - let result = c30_l89_action_invoke(&mut*instance); + let result = c30_l89_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -371,14 +385,14 @@ fn c30_l89_assert_trap() { fn c31_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c31_l90_action_invoke"); let result = instance.call("callu", &[Value::I32(100 as i32)]); - + result.map(|_| ()) } #[test] fn c31_l90_assert_trap() { let mut instance = create_module_2(); - let result = c31_l90_action_invoke(&mut*instance); + let result = c31_l90_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -386,14 +400,14 @@ fn c31_l90_assert_trap() { fn c32_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c32_l91_action_invoke"); let result = instance.call("callu", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c32_l91_assert_trap() { let mut instance = create_module_2(); - let result = c32_l91_action_invoke(&mut*instance); + let result = c32_l91_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -435,8 +449,11 @@ fn create_module_3() -> Box { (elem (;0;) (i32.const 0) 0 1)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { diff --git a/lib/runtime/tests/spectests/get_local.rs b/lib/runtime/tests/spectests/get_local.rs index cb973f351..5867e8fa0 100644 --- a/lib/runtime/tests/spectests/get_local.rs +++ b/lib/runtime/tests/spectests/get_local.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -124,8 +120,11 @@ fn create_module_1() -> Box { (export \"read\" (func 9))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -200,7 +199,16 @@ fn c8_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 75 fn c9_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c9_l75_action_invoke"); - let result = instance.call("type-mixed", &[Value::I64(1 as i64), Value::F32((2.2f32)), Value::F64((3.3f64)), Value::I32(4 as i32), Value::I32(5 as i32)]); + let result = instance.call( + "type-mixed", + &[ + Value::I64(1 as i64), + Value::F32((2.2f32)), + Value::F64((3.3f64)), + Value::I32(4 as i32), + Value::I32(5 as i32), + ], + ); assert_eq!(result, Ok(None)); result.map(|_| ()) } @@ -208,7 +216,16 @@ fn c9_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 81 fn c10_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c10_l81_action_invoke"); - let result = instance.call("read", &[Value::I64(1 as i64), Value::F32((2.0f32)), Value::F64((3.3f64)), Value::I32(4 as i32), Value::I32(5 as i32)]); + let result = instance.call( + "read", + &[ + Value::I64(1 as i64), + Value::F32((2.0f32)), + Value::F64((3.3f64)), + Value::I32(4 as i32), + Value::I32(5 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::F64((34.8f64))))); result.map(|_| ()) } @@ -216,7 +233,10 @@ fn c10_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 91 #[test] fn c11_l91_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 8, 1, 6, 1, 1, 127, 32, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 8, 1, 6, 1, 1, 127, + 32, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -224,7 +244,10 @@ fn c11_l91_assert_invalid() { // Line 95 #[test] fn c12_l95_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 1, 1, 125, 32, 0, 69, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 1, 1, 125, 32, 0, + 69, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -232,7 +255,10 @@ fn c12_l95_assert_invalid() { // Line 99 #[test] fn c13_l99_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 2, 1, 124, 1, 126, 32, 1, 154, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 2, 1, 124, 1, + 126, 32, 1, 154, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -240,7 +266,10 @@ fn c13_l99_assert_invalid() { // Line 107 #[test] fn c14_l107_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 126, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 126, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, + 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -248,7 +277,10 @@ fn c14_l107_assert_invalid() { // Line 111 #[test] fn c15_l111_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 0, 69, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 0, 69, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -256,7 +288,10 @@ fn c15_l111_assert_invalid() { // Line 115 #[test] fn c16_l115_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 1, 154, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, + 1, 154, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -264,7 +299,10 @@ fn c16_l115_assert_invalid() { // Line 123 #[test] fn c17_l123_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, 126, 32, 3, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, + 126, 32, 3, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -272,7 +310,10 @@ fn c17_l123_assert_invalid() { // Line 127 #[test] fn c18_l127_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, 126, 32, 247, 164, 234, 6, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, + 126, 32, 247, 164, 234, 6, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -280,7 +321,10 @@ fn c18_l127_assert_invalid() { // Line 132 #[test] fn c19_l132_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 127, 126, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, 2, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 127, 126, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, + 2, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -288,7 +332,10 @@ fn c19_l132_assert_invalid() { // Line 136 #[test] fn c20_l136_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 2, 1, 127, 1, 126, 32, 247, 242, 206, 212, 2, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 2, 1, 127, 1, + 126, 32, 247, 242, 206, 212, 2, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -296,7 +343,10 @@ fn c20_l136_assert_invalid() { // Line 141 #[test] fn c21_l141_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, 126, 32, 3, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, + 1, 126, 32, 3, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -304,7 +354,10 @@ fn c21_l141_assert_invalid() { // Line 145 #[test] fn c22_l145_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, 126, 32, 247, 168, 153, 102, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, + 1, 126, 32, 247, 168, 153, 102, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/globals.rs b/lib/runtime/tests/spectests/globals.rs index 0f1285756..cd25412ed 100644 --- a/lib/runtime/tests/spectests/globals.rs +++ b/lib/runtime/tests/spectests/globals.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 4 fn create_module_1() -> Box { @@ -275,8 +271,11 @@ fn create_module_1() -> Box { (elem (;0;) (i32.const 0) 26)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -536,14 +535,14 @@ fn c31_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c32_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c32_l222_action_invoke"); let result = instance.call("as-call_indirect-last", &[]); - + result.map(|_| ()) } #[test] fn c32_l222_assert_trap() { let mut instance = create_module_1(); - let result = c32_l222_action_invoke(&mut*instance); + let result = c32_l222_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -662,7 +661,10 @@ fn c46_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 244 #[test] fn c47_l244_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 6, 9, 1, 125, 0, 67, 0, 0, 0, 0, 11, 10, 8, 1, 6, 0, 65, 1, 36, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 6, 9, 1, 125, 0, 67, 0, 0, 0, + 0, 11, 10, 8, 1, 6, 0, 65, 1, 36, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -670,7 +672,9 @@ fn c47_l244_assert_invalid() { // Line 256 #[test] fn c48_l256_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 125, 0, 67, 0, 0, 0, 0, 140, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 125, 0, 67, 0, 0, 0, 0, 140, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -686,7 +690,9 @@ fn c49_l261_assert_invalid() { // Line 266 #[test] fn c50_l266_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 125, 0, 67, 0, 0, 128, 63, 140, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 125, 0, 67, 0, 0, 128, 63, 140, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -710,7 +716,9 @@ fn c52_l276_assert_invalid() { // Line 281 #[test] fn c53_l281_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 9, 1, 127, 0, 67, 0, 0, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 9, 1, 127, 0, 67, 0, 0, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -718,7 +726,9 @@ fn c53_l281_assert_invalid() { // Line 286 #[test] fn c54_l286_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 8, 1, 127, 0, 65, 0, 65, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 8, 1, 127, 0, 65, 0, 65, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -726,7 +736,9 @@ fn c54_l286_assert_invalid() { // Line 291 #[test] fn c55_l291_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 2, 127, 0, 65, 0, 11, 126, 0, 35, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 2, 127, 0, 65, 0, 11, 126, 0, 35, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -750,7 +762,9 @@ fn c57_l302_assert_invalid() { // Line 307 #[test] fn c58_l307_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 2, 127, 0, 35, 1, 11, 127, 0, 65, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 2, 127, 0, 35, 1, 11, 127, 0, 65, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -821,8 +835,11 @@ fn create_module_2() -> Box { (export \"get-0-ref\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -849,17 +866,29 @@ fn c61_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 322 #[test] fn c62_l322_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 2, 148, 128, 128, 128, 0, 1, 8, 115, 112, 101, 99, 116, 101, 115, 116, 10, 103, 108, 111, 98, 97, 108, 95, 105, 51, 50, 3, 127, 2]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 2, 148, 128, 128, 128, 0, 1, 8, 115, 112, 101, 99, 116, 101, + 115, 116, 10, 103, 108, 111, 98, 97, 108, 95, 105, 51, 50, 3, 127, 2, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 335 #[test] fn c63_l335_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 2, 148, 128, 128, 128, 0, 1, 8, 115, 112, 101, 99, 116, 101, 115, 116, 10, 103, 108, 111, 98, 97, 108, 95, 105, 51, 50, 3, 127, 255]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 2, 148, 128, 128, 128, 0, 1, 8, 115, 112, 101, 99, 116, 101, + 115, 116, 10, 103, 108, 111, 98, 97, 108, 95, 105, 51, 50, 3, 127, 255, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 348 @@ -877,8 +906,11 @@ fn create_module_3() -> Box { (global (;0;) i32 (i32.const 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -889,17 +921,27 @@ fn start_module_3(instance: &mut Instance) { // Line 352 #[test] fn c65_l352_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 134, 128, 128, 128, 0, 1, 127, 2, 65, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 134, 128, 128, 128, 0, 1, 127, 2, 65, 0, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 364 #[test] fn c66_l364_assert_malformed() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 134, 128, 128, 128, 0, 1, 127, 255, 65, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 6, 134, 128, 128, 128, 0, 1, 127, 255, 65, 0, 11, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } #[test] diff --git a/lib/runtime/tests/spectests/i32_.rs b/lib/runtime/tests/spectests/i32_.rs index fd565bf16..2a4730bd1 100644 --- a/lib/runtime/tests/spectests/i32_.rs +++ b/lib/runtime/tests/spectests/i32_.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -166,8 +162,11 @@ fn create_module_1() -> Box { (export \"ge_u\" (func 28))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -210,7 +209,10 @@ fn c4_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 39 fn c5_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c5_l39_action_invoke"); - let result = instance.call("add", &[Value::I32(2147483647 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "add", + &[Value::I32(2147483647 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); result.map(|_| ()) } @@ -218,7 +220,10 @@ fn c5_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 40 fn c6_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c6_l40_action_invoke"); - let result = instance.call("add", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "add", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32)))); result.map(|_| ()) } @@ -226,7 +231,13 @@ fn c6_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 41 fn c7_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c7_l41_action_invoke"); - let result = instance.call("add", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "add", + &[ + Value::I32(-2147483648 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -234,7 +245,10 @@ fn c7_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 42 fn c8_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c8_l42_action_invoke"); - let result = instance.call("add", &[Value::I32(1073741823 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "add", + &[Value::I32(1073741823 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1073741824 as i32)))); result.map(|_| ()) } @@ -266,7 +280,10 @@ fn c11_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 47 fn c12_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c12_l47_action_invoke"); - let result = instance.call("sub", &[Value::I32(2147483647 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "sub", + &[Value::I32(2147483647 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); result.map(|_| ()) } @@ -274,7 +291,10 @@ fn c12_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 48 fn c13_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c13_l48_action_invoke"); - let result = instance.call("sub", &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "sub", + &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32)))); result.map(|_| ()) } @@ -282,7 +302,13 @@ fn c13_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 49 fn c14_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c14_l49_action_invoke"); - let result = instance.call("sub", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "sub", + &[ + Value::I32(-2147483648 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -290,7 +316,10 @@ fn c14_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 50 fn c15_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c15_l50_action_invoke"); - let result = instance.call("sub", &[Value::I32(1073741823 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "sub", + &[Value::I32(1073741823 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1073741824 as i32)))); result.map(|_| ()) } @@ -322,7 +351,10 @@ fn c18_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 55 fn c19_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c19_l55_action_invoke"); - let result = instance.call("mul", &[Value::I32(268435456 as i32), Value::I32(4096 as i32)]); + let result = instance.call( + "mul", + &[Value::I32(268435456 as i32), Value::I32(4096 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -330,7 +362,10 @@ fn c19_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 56 fn c20_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c20_l56_action_invoke"); - let result = instance.call("mul", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "mul", + &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -338,7 +373,10 @@ fn c20_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 57 fn c21_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c21_l57_action_invoke"); - let result = instance.call("mul", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "mul", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); result.map(|_| ()) } @@ -346,7 +384,10 @@ fn c21_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 58 fn c22_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c22_l58_action_invoke"); - let result = instance.call("mul", &[Value::I32(2147483647 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "mul", + &[Value::I32(2147483647 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-2147483647 as i32)))); result.map(|_| ()) } @@ -354,7 +395,10 @@ fn c22_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 59 fn c23_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c23_l59_action_invoke"); - let result = instance.call("mul", &[Value::I32(19088743 as i32), Value::I32(1985229328 as i32)]); + let result = instance.call( + "mul", + &[Value::I32(19088743 as i32), Value::I32(1985229328 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(898528368 as i32)))); result.map(|_| ()) } @@ -362,7 +406,10 @@ fn c23_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 60 fn c24_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c24_l60_action_invoke"); - let result = instance.call("mul", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "mul", + &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -371,14 +418,14 @@ fn c24_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c25_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c25_l62_action_invoke"); let result = instance.call("div_s", &[Value::I32(1 as i32), Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c25_l62_assert_trap() { let mut instance = create_module_1(); - let result = c25_l62_action_invoke(&mut*instance); + let result = c25_l62_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -386,29 +433,32 @@ fn c25_l62_assert_trap() { fn c26_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c26_l63_action_invoke"); let result = instance.call("div_s", &[Value::I32(0 as i32), Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c26_l63_assert_trap() { let mut instance = create_module_1(); - let result = c26_l63_action_invoke(&mut*instance); + let result = c26_l63_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 64 fn c27_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c27_l64_action_invoke"); - let result = instance.call("div_s", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); - + let result = instance.call( + "div_s", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); + result.map(|_| ()) } #[test] fn c27_l64_assert_trap() { let mut instance = create_module_1(); - let result = c27_l64_action_invoke(&mut*instance); + let result = c27_l64_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -447,7 +497,10 @@ fn c31_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 69 fn c32_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c32_l69_action_invoke"); - let result = instance.call("div_s", &[Value::I32(-2147483648 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "div_s", + &[Value::I32(-2147483648 as i32), Value::I32(2 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-1073741824 as i32)))); result.map(|_| ()) } @@ -455,7 +508,10 @@ fn c32_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 70 fn c33_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c33_l70_action_invoke"); - let result = instance.call("div_s", &[Value::I32(-2147483647 as i32), Value::I32(1000 as i32)]); + let result = instance.call( + "div_s", + &[Value::I32(-2147483647 as i32), Value::I32(1000 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-2147483 as i32)))); result.map(|_| ()) } @@ -544,14 +600,14 @@ fn c43_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c44_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c44_l82_action_invoke"); let result = instance.call("div_u", &[Value::I32(1 as i32), Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c44_l82_assert_trap() { let mut instance = create_module_1(); - let result = c44_l82_action_invoke(&mut*instance); + let result = c44_l82_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -559,14 +615,14 @@ fn c44_l82_assert_trap() { fn c45_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c45_l83_action_invoke"); let result = instance.call("div_u", &[Value::I32(0 as i32), Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c45_l83_assert_trap() { let mut instance = create_module_1(); - let result = c45_l83_action_invoke(&mut*instance); + let result = c45_l83_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -597,7 +653,10 @@ fn c48_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 87 fn c49_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c49_l87_action_invoke"); - let result = instance.call("div_u", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "div_u", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -605,7 +664,10 @@ fn c49_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 88 fn c50_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c50_l88_action_invoke"); - let result = instance.call("div_u", &[Value::I32(-2147483648 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "div_u", + &[Value::I32(-2147483648 as i32), Value::I32(2 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1073741824 as i32)))); result.map(|_| ()) } @@ -613,7 +675,10 @@ fn c50_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 89 fn c51_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c51_l89_action_invoke"); - let result = instance.call("div_u", &[Value::I32(-1880092688 as i32), Value::I32(65537 as i32)]); + let result = instance.call( + "div_u", + &[Value::I32(-1880092688 as i32), Value::I32(65537 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(36847 as i32)))); result.map(|_| ()) } @@ -621,7 +686,10 @@ fn c51_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 90 fn c52_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c52_l90_action_invoke"); - let result = instance.call("div_u", &[Value::I32(-2147483647 as i32), Value::I32(1000 as i32)]); + let result = instance.call( + "div_u", + &[Value::I32(-2147483647 as i32), Value::I32(1000 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2147483 as i32)))); result.map(|_| ()) } @@ -686,14 +754,14 @@ fn c59_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c60_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c60_l99_action_invoke"); let result = instance.call("rem_s", &[Value::I32(1 as i32), Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c60_l99_assert_trap() { let mut instance = create_module_1(); - let result = c60_l99_action_invoke(&mut*instance); + let result = c60_l99_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -701,21 +769,24 @@ fn c60_l99_assert_trap() { fn c61_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c61_l100_action_invoke"); let result = instance.call("rem_s", &[Value::I32(0 as i32), Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c61_l100_assert_trap() { let mut instance = create_module_1(); - let result = c61_l100_action_invoke(&mut*instance); + let result = c61_l100_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 101 fn c62_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c62_l101_action_invoke"); - let result = instance.call("rem_s", &[Value::I32(2147483647 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "rem_s", + &[Value::I32(2147483647 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -755,7 +826,10 @@ fn c66_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 106 fn c67_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c67_l106_action_invoke"); - let result = instance.call("rem_s", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "rem_s", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -763,7 +837,10 @@ fn c67_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 107 fn c68_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c68_l107_action_invoke"); - let result = instance.call("rem_s", &[Value::I32(-2147483648 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "rem_s", + &[Value::I32(-2147483648 as i32), Value::I32(2 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -771,7 +848,10 @@ fn c68_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 108 fn c69_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c69_l108_action_invoke"); - let result = instance.call("rem_s", &[Value::I32(-2147483647 as i32), Value::I32(1000 as i32)]); + let result = instance.call( + "rem_s", + &[Value::I32(-2147483647 as i32), Value::I32(1000 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-647 as i32)))); result.map(|_| ()) } @@ -860,14 +940,14 @@ fn c79_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c80_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c80_l120_action_invoke"); let result = instance.call("rem_u", &[Value::I32(1 as i32), Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c80_l120_assert_trap() { let mut instance = create_module_1(); - let result = c80_l120_action_invoke(&mut*instance); + let result = c80_l120_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -875,14 +955,14 @@ fn c80_l120_assert_trap() { fn c81_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c81_l121_action_invoke"); let result = instance.call("rem_u", &[Value::I32(0 as i32), Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c81_l121_assert_trap() { let mut instance = create_module_1(); - let result = c81_l121_action_invoke(&mut*instance); + let result = c81_l121_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -913,7 +993,10 @@ fn c84_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 125 fn c85_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c85_l125_action_invoke"); - let result = instance.call("rem_u", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "rem_u", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); result.map(|_| ()) } @@ -921,7 +1004,10 @@ fn c85_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 126 fn c86_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c86_l126_action_invoke"); - let result = instance.call("rem_u", &[Value::I32(-2147483648 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "rem_u", + &[Value::I32(-2147483648 as i32), Value::I32(2 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -929,7 +1015,10 @@ fn c86_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 127 fn c87_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c87_l127_action_invoke"); - let result = instance.call("rem_u", &[Value::I32(-1880092688 as i32), Value::I32(65537 as i32)]); + let result = instance.call( + "rem_u", + &[Value::I32(-1880092688 as i32), Value::I32(65537 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(32769 as i32)))); result.map(|_| ()) } @@ -937,7 +1026,10 @@ fn c87_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 128 fn c88_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c88_l128_action_invoke"); - let result = instance.call("rem_u", &[Value::I32(-2147483647 as i32), Value::I32(1000 as i32)]); + let result = instance.call( + "rem_u", + &[Value::I32(-2147483647 as i32), Value::I32(1000 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(649 as i32)))); result.map(|_| ()) } @@ -1033,7 +1125,13 @@ fn c99_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 141 fn c100_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c100_l141_action_invoke"); - let result = instance.call("and", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "and", + &[ + Value::I32(2147483647 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1041,7 +1139,10 @@ fn c100_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 142 fn c101_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c101_l142_action_invoke"); - let result = instance.call("and", &[Value::I32(2147483647 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "and", + &[Value::I32(2147483647 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32)))); result.map(|_| ()) } @@ -1049,7 +1150,10 @@ fn c101_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 143 fn c102_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c102_l143_action_invoke"); - let result = instance.call("and", &[Value::I32(-252641281 as i32), Value::I32(-3856 as i32)]); + let result = instance.call( + "and", + &[Value::I32(-252641281 as i32), Value::I32(-3856 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-252645136 as i32)))); result.map(|_| ()) } @@ -1097,7 +1201,13 @@ fn c107_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 150 fn c108_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c108_l150_action_invoke"); - let result = instance.call("or", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "or", + &[ + Value::I32(2147483647 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); result.map(|_| ()) } @@ -1105,7 +1215,10 @@ fn c108_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 151 fn c109_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c109_l151_action_invoke"); - let result = instance.call("or", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "or", + &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); result.map(|_| ()) } @@ -1113,7 +1226,10 @@ fn c109_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 152 fn c110_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c110_l152_action_invoke"); - let result = instance.call("or", &[Value::I32(-252641281 as i32), Value::I32(-3856 as i32)]); + let result = instance.call( + "or", + &[Value::I32(-252641281 as i32), Value::I32(-3856 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); result.map(|_| ()) } @@ -1161,7 +1277,13 @@ fn c115_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 159 fn c116_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c116_l159_action_invoke"); - let result = instance.call("xor", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "xor", + &[ + Value::I32(2147483647 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); result.map(|_| ()) } @@ -1169,7 +1291,10 @@ fn c116_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 160 fn c117_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c117_l160_action_invoke"); - let result = instance.call("xor", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "xor", + &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); result.map(|_| ()) } @@ -1177,7 +1302,10 @@ fn c117_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 161 fn c118_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c118_l161_action_invoke"); - let result = instance.call("xor", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "xor", + &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32)))); result.map(|_| ()) } @@ -1185,7 +1313,10 @@ fn c118_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 162 fn c119_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c119_l162_action_invoke"); - let result = instance.call("xor", &[Value::I32(-1 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "xor", + &[Value::I32(-1 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); result.map(|_| ()) } @@ -1193,7 +1324,10 @@ fn c119_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 163 fn c120_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c120_l163_action_invoke"); - let result = instance.call("xor", &[Value::I32(-252641281 as i32), Value::I32(-3856 as i32)]); + let result = instance.call( + "xor", + &[Value::I32(-252641281 as i32), Value::I32(-3856 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(252645135 as i32)))); result.map(|_| ()) } @@ -1225,7 +1359,10 @@ fn c123_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 168 fn c124_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c124_l168_action_invoke"); - let result = instance.call("shl", &[Value::I32(2147483647 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "shl", + &[Value::I32(2147483647 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-2 as i32)))); result.map(|_| ()) } @@ -1241,7 +1378,10 @@ fn c125_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 170 fn c126_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c126_l170_action_invoke"); - let result = instance.call("shl", &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "shl", + &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1249,7 +1389,10 @@ fn c126_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 171 fn c127_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c127_l171_action_invoke"); - let result = instance.call("shl", &[Value::I32(1073741824 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "shl", + &[Value::I32(1073741824 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); result.map(|_| ()) } @@ -1289,7 +1432,10 @@ fn c131_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 176 fn c132_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c132_l176_action_invoke"); - let result = instance.call("shl", &[Value::I32(1 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "shl", + &[Value::I32(1 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); result.map(|_| ()) } @@ -1321,7 +1467,10 @@ fn c135_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 181 fn c136_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c136_l181_action_invoke"); - let result = instance.call("shr_s", &[Value::I32(2147483647 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "shr_s", + &[Value::I32(2147483647 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1073741823 as i32)))); result.map(|_| ()) } @@ -1329,7 +1478,10 @@ fn c136_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 182 fn c137_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c137_l182_action_invoke"); - let result = instance.call("shr_s", &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "shr_s", + &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-1073741824 as i32)))); result.map(|_| ()) } @@ -1337,7 +1489,10 @@ fn c137_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 183 fn c138_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c138_l183_action_invoke"); - let result = instance.call("shr_s", &[Value::I32(1073741824 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "shr_s", + &[Value::I32(1073741824 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(536870912 as i32)))); result.map(|_| ()) } @@ -1369,7 +1524,10 @@ fn c141_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 187 fn c142_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c142_l187_action_invoke"); - let result = instance.call("shr_s", &[Value::I32(1 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "shr_s", + &[Value::I32(1 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1377,7 +1535,10 @@ fn c142_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 188 fn c143_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c143_l188_action_invoke"); - let result = instance.call("shr_s", &[Value::I32(1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "shr_s", + &[Value::I32(1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1385,7 +1546,10 @@ fn c143_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 189 fn c144_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c144_l189_action_invoke"); - let result = instance.call("shr_s", &[Value::I32(-2147483648 as i32), Value::I32(31 as i32)]); + let result = instance.call( + "shr_s", + &[Value::I32(-2147483648 as i32), Value::I32(31 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); result.map(|_| ()) } @@ -1417,7 +1581,10 @@ fn c147_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 193 fn c148_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c148_l193_action_invoke"); - let result = instance.call("shr_s", &[Value::I32(-1 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "shr_s", + &[Value::I32(-1 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); result.map(|_| ()) } @@ -1425,7 +1592,10 @@ fn c148_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 194 fn c149_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c149_l194_action_invoke"); - let result = instance.call("shr_s", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "shr_s", + &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); result.map(|_| ()) } @@ -1457,7 +1627,10 @@ fn c152_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 199 fn c153_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c153_l199_action_invoke"); - let result = instance.call("shr_u", &[Value::I32(2147483647 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "shr_u", + &[Value::I32(2147483647 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1073741823 as i32)))); result.map(|_| ()) } @@ -1465,7 +1638,10 @@ fn c153_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 200 fn c154_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c154_l200_action_invoke"); - let result = instance.call("shr_u", &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "shr_u", + &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1073741824 as i32)))); result.map(|_| ()) } @@ -1473,7 +1649,10 @@ fn c154_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 201 fn c155_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c155_l201_action_invoke"); - let result = instance.call("shr_u", &[Value::I32(1073741824 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "shr_u", + &[Value::I32(1073741824 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(536870912 as i32)))); result.map(|_| ()) } @@ -1505,7 +1684,10 @@ fn c158_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 205 fn c159_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c159_l205_action_invoke"); - let result = instance.call("shr_u", &[Value::I32(1 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "shr_u", + &[Value::I32(1 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1513,7 +1695,10 @@ fn c159_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 206 fn c160_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c160_l206_action_invoke"); - let result = instance.call("shr_u", &[Value::I32(1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "shr_u", + &[Value::I32(1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1521,7 +1706,10 @@ fn c160_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 207 fn c161_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c161_l207_action_invoke"); - let result = instance.call("shr_u", &[Value::I32(-2147483648 as i32), Value::I32(31 as i32)]); + let result = instance.call( + "shr_u", + &[Value::I32(-2147483648 as i32), Value::I32(31 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1553,7 +1741,10 @@ fn c164_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 211 fn c165_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c165_l211_action_invoke"); - let result = instance.call("shr_u", &[Value::I32(-1 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "shr_u", + &[Value::I32(-1 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1561,7 +1752,10 @@ fn c165_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 212 fn c166_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c166_l212_action_invoke"); - let result = instance.call("shr_u", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "shr_u", + &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); result.map(|_| ()) } @@ -1601,7 +1795,10 @@ fn c170_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 218 fn c171_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c171_l218_action_invoke"); - let result = instance.call("rotl", &[Value::I32(-1412589450 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "rotl", + &[Value::I32(-1412589450 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1469788397 as i32)))); result.map(|_| ()) } @@ -1609,7 +1806,10 @@ fn c171_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 219 fn c172_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c172_l219_action_invoke"); - let result = instance.call("rotl", &[Value::I32(-33498112 as i32), Value::I32(4 as i32)]); + let result = instance.call( + "rotl", + &[Value::I32(-33498112 as i32), Value::I32(4 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-535969777 as i32)))); result.map(|_| ()) } @@ -1617,7 +1817,10 @@ fn c172_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 220 fn c173_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c173_l220_action_invoke"); - let result = instance.call("rotl", &[Value::I32(-1329474845 as i32), Value::I32(5 as i32)]); + let result = instance.call( + "rotl", + &[Value::I32(-1329474845 as i32), Value::I32(5 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(406477942 as i32)))); result.map(|_| ()) } @@ -1633,7 +1836,10 @@ fn c174_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 222 fn c175_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c175_l222_action_invoke"); - let result = instance.call("rotl", &[Value::I32(-1329474845 as i32), Value::I32(65285 as i32)]); + let result = instance.call( + "rotl", + &[Value::I32(-1329474845 as i32), Value::I32(65285 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(406477942 as i32)))); result.map(|_| ()) } @@ -1641,7 +1847,10 @@ fn c175_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 223 fn c176_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c176_l223_action_invoke"); - let result = instance.call("rotl", &[Value::I32(1989852383 as i32), Value::I32(-19 as i32)]); + let result = instance.call( + "rotl", + &[Value::I32(1989852383 as i32), Value::I32(-19 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1469837011 as i32)))); result.map(|_| ()) } @@ -1649,7 +1858,13 @@ fn c176_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 224 fn c177_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c177_l224_action_invoke"); - let result = instance.call("rotl", &[Value::I32(1989852383 as i32), Value::I32(-2147483635 as i32)]); + let result = instance.call( + "rotl", + &[ + Value::I32(1989852383 as i32), + Value::I32(-2147483635 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1469837011 as i32)))); result.map(|_| ()) } @@ -1665,7 +1880,10 @@ fn c178_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 226 fn c179_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c179_l226_action_invoke"); - let result = instance.call("rotl", &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "rotl", + &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1705,7 +1923,10 @@ fn c183_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 232 fn c184_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c184_l232_action_invoke"); - let result = instance.call("rotr", &[Value::I32(-16724992 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "rotr", + &[Value::I32(-16724992 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(2139121152 as i32)))); result.map(|_| ()) } @@ -1721,7 +1942,10 @@ fn c185_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 234 fn c186_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c186_l234_action_invoke"); - let result = instance.call("rotr", &[Value::I32(-1329474845 as i32), Value::I32(5 as i32)]); + let result = instance.call( + "rotr", + &[Value::I32(-1329474845 as i32), Value::I32(5 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(495324823 as i32)))); result.map(|_| ()) } @@ -1737,7 +1961,10 @@ fn c187_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 236 fn c188_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c188_l236_action_invoke"); - let result = instance.call("rotr", &[Value::I32(-1329474845 as i32), Value::I32(65285 as i32)]); + let result = instance.call( + "rotr", + &[Value::I32(-1329474845 as i32), Value::I32(65285 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(495324823 as i32)))); result.map(|_| ()) } @@ -1745,7 +1972,10 @@ fn c188_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 237 fn c189_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c189_l237_action_invoke"); - let result = instance.call("rotr", &[Value::I32(1989852383 as i32), Value::I32(-19 as i32)]); + let result = instance.call( + "rotr", + &[Value::I32(1989852383 as i32), Value::I32(-19 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-419711787 as i32)))); result.map(|_| ()) } @@ -1753,7 +1983,13 @@ fn c189_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 238 fn c190_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c190_l238_action_invoke"); - let result = instance.call("rotr", &[Value::I32(1989852383 as i32), Value::I32(-2147483635 as i32)]); + let result = instance.call( + "rotr", + &[ + Value::I32(1989852383 as i32), + Value::I32(-2147483635 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(-419711787 as i32)))); result.map(|_| ()) } @@ -1769,7 +2005,10 @@ fn c191_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 240 fn c192_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c192_l240_action_invoke"); - let result = instance.call("rotr", &[Value::I32(-2147483648 as i32), Value::I32(31 as i32)]); + let result = instance.call( + "rotr", + &[Value::I32(-2147483648 as i32), Value::I32(31 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2017,7 +2256,13 @@ fn c222_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 276 fn c223_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c223_l276_action_invoke"); - let result = instance.call("eq", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "eq", + &[ + Value::I32(-2147483648 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2025,7 +2270,10 @@ fn c223_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 277 fn c224_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c224_l277_action_invoke"); - let result = instance.call("eq", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "eq", + &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2057,7 +2305,10 @@ fn c227_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 281 fn c228_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c228_l281_action_invoke"); - let result = instance.call("eq", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "eq", + &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2065,7 +2316,10 @@ fn c228_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 282 fn c229_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c229_l282_action_invoke"); - let result = instance.call("eq", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "eq", + &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2073,7 +2327,10 @@ fn c229_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 283 fn c230_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c230_l283_action_invoke"); - let result = instance.call("eq", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "eq", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2081,7 +2338,10 @@ fn c230_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 284 fn c231_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c231_l284_action_invoke"); - let result = instance.call("eq", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "eq", + &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2089,7 +2349,13 @@ fn c231_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 285 fn c232_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c232_l285_action_invoke"); - let result = instance.call("eq", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "eq", + &[ + Value::I32(-2147483648 as i32), + Value::I32(2147483647 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2097,7 +2363,13 @@ fn c232_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 286 fn c233_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c233_l286_action_invoke"); - let result = instance.call("eq", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "eq", + &[ + Value::I32(2147483647 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2129,7 +2401,13 @@ fn c236_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 291 fn c237_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c237_l291_action_invoke"); - let result = instance.call("ne", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "ne", + &[ + Value::I32(-2147483648 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2137,7 +2415,10 @@ fn c237_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 292 fn c238_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c238_l292_action_invoke"); - let result = instance.call("ne", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "ne", + &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2169,7 +2450,10 @@ fn c241_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 296 fn c242_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c242_l296_action_invoke"); - let result = instance.call("ne", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "ne", + &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2177,7 +2461,10 @@ fn c242_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 297 fn c243_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c243_l297_action_invoke"); - let result = instance.call("ne", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "ne", + &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2185,7 +2472,10 @@ fn c243_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 298 fn c244_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c244_l298_action_invoke"); - let result = instance.call("ne", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "ne", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2193,7 +2483,10 @@ fn c244_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 299 fn c245_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c245_l299_action_invoke"); - let result = instance.call("ne", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "ne", + &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2201,7 +2494,13 @@ fn c245_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 300 fn c246_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c246_l300_action_invoke"); - let result = instance.call("ne", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "ne", + &[ + Value::I32(-2147483648 as i32), + Value::I32(2147483647 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2209,7 +2508,13 @@ fn c246_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 301 fn c247_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c247_l301_action_invoke"); - let result = instance.call("ne", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "ne", + &[ + Value::I32(2147483647 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2241,7 +2546,13 @@ fn c250_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 306 fn c251_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c251_l306_action_invoke"); - let result = instance.call("lt_s", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "lt_s", + &[ + Value::I32(-2147483648 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2249,7 +2560,10 @@ fn c251_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 307 fn c252_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c252_l307_action_invoke"); - let result = instance.call("lt_s", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "lt_s", + &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2281,7 +2595,10 @@ fn c255_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 311 fn c256_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c256_l311_action_invoke"); - let result = instance.call("lt_s", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "lt_s", + &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2289,7 +2606,10 @@ fn c256_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 312 fn c257_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c257_l312_action_invoke"); - let result = instance.call("lt_s", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "lt_s", + &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2297,7 +2617,10 @@ fn c257_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 313 fn c258_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c258_l313_action_invoke"); - let result = instance.call("lt_s", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "lt_s", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2305,7 +2628,10 @@ fn c258_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 314 fn c259_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c259_l314_action_invoke"); - let result = instance.call("lt_s", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "lt_s", + &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2313,7 +2639,13 @@ fn c259_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 315 fn c260_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c260_l315_action_invoke"); - let result = instance.call("lt_s", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "lt_s", + &[ + Value::I32(-2147483648 as i32), + Value::I32(2147483647 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2321,7 +2653,13 @@ fn c260_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 316 fn c261_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c261_l316_action_invoke"); - let result = instance.call("lt_s", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "lt_s", + &[ + Value::I32(2147483647 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2353,7 +2691,13 @@ fn c264_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 321 fn c265_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c265_l321_action_invoke"); - let result = instance.call("lt_u", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "lt_u", + &[ + Value::I32(-2147483648 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2361,7 +2705,10 @@ fn c265_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 322 fn c266_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c266_l322_action_invoke"); - let result = instance.call("lt_u", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "lt_u", + &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2393,7 +2740,10 @@ fn c269_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 326 fn c270_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c270_l326_action_invoke"); - let result = instance.call("lt_u", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "lt_u", + &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2401,7 +2751,10 @@ fn c270_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 327 fn c271_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c271_l327_action_invoke"); - let result = instance.call("lt_u", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "lt_u", + &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2409,7 +2762,10 @@ fn c271_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 328 fn c272_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c272_l328_action_invoke"); - let result = instance.call("lt_u", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "lt_u", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2417,7 +2773,10 @@ fn c272_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 329 fn c273_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c273_l329_action_invoke"); - let result = instance.call("lt_u", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "lt_u", + &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2425,7 +2784,13 @@ fn c273_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 330 fn c274_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c274_l330_action_invoke"); - let result = instance.call("lt_u", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "lt_u", + &[ + Value::I32(-2147483648 as i32), + Value::I32(2147483647 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2433,7 +2798,13 @@ fn c274_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 331 fn c275_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c275_l331_action_invoke"); - let result = instance.call("lt_u", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "lt_u", + &[ + Value::I32(2147483647 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2465,7 +2836,13 @@ fn c278_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 336 fn c279_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c279_l336_action_invoke"); - let result = instance.call("le_s", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "le_s", + &[ + Value::I32(-2147483648 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2473,7 +2850,10 @@ fn c279_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 337 fn c280_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c280_l337_action_invoke"); - let result = instance.call("le_s", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "le_s", + &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2505,7 +2885,10 @@ fn c283_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 341 fn c284_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c284_l341_action_invoke"); - let result = instance.call("le_s", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "le_s", + &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2513,7 +2896,10 @@ fn c284_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 342 fn c285_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c285_l342_action_invoke"); - let result = instance.call("le_s", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "le_s", + &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2521,7 +2907,10 @@ fn c285_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 343 fn c286_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c286_l343_action_invoke"); - let result = instance.call("le_s", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "le_s", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2529,7 +2918,10 @@ fn c286_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 344 fn c287_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c287_l344_action_invoke"); - let result = instance.call("le_s", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "le_s", + &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2537,7 +2929,13 @@ fn c287_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 345 fn c288_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c288_l345_action_invoke"); - let result = instance.call("le_s", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "le_s", + &[ + Value::I32(-2147483648 as i32), + Value::I32(2147483647 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2545,7 +2943,13 @@ fn c288_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 346 fn c289_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c289_l346_action_invoke"); - let result = instance.call("le_s", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "le_s", + &[ + Value::I32(2147483647 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2577,7 +2981,13 @@ fn c292_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 351 fn c293_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c293_l351_action_invoke"); - let result = instance.call("le_u", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "le_u", + &[ + Value::I32(-2147483648 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2585,7 +2995,10 @@ fn c293_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 352 fn c294_l352_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c294_l352_action_invoke"); - let result = instance.call("le_u", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "le_u", + &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2617,7 +3030,10 @@ fn c297_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 356 fn c298_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c298_l356_action_invoke"); - let result = instance.call("le_u", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "le_u", + &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2625,7 +3041,10 @@ fn c298_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 357 fn c299_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c299_l357_action_invoke"); - let result = instance.call("le_u", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "le_u", + &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2633,7 +3052,10 @@ fn c299_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 358 fn c300_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c300_l358_action_invoke"); - let result = instance.call("le_u", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "le_u", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2641,7 +3063,10 @@ fn c300_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 359 fn c301_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c301_l359_action_invoke"); - let result = instance.call("le_u", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "le_u", + &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2649,7 +3074,13 @@ fn c301_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 360 fn c302_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c302_l360_action_invoke"); - let result = instance.call("le_u", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "le_u", + &[ + Value::I32(-2147483648 as i32), + Value::I32(2147483647 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2657,7 +3088,13 @@ fn c302_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 361 fn c303_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c303_l361_action_invoke"); - let result = instance.call("le_u", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "le_u", + &[ + Value::I32(2147483647 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2689,7 +3126,13 @@ fn c306_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 366 fn c307_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c307_l366_action_invoke"); - let result = instance.call("gt_s", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "gt_s", + &[ + Value::I32(-2147483648 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2697,7 +3140,10 @@ fn c307_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 367 fn c308_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c308_l367_action_invoke"); - let result = instance.call("gt_s", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "gt_s", + &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2729,7 +3175,10 @@ fn c311_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 371 fn c312_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c312_l371_action_invoke"); - let result = instance.call("gt_s", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "gt_s", + &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2737,7 +3186,10 @@ fn c312_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 372 fn c313_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c313_l372_action_invoke"); - let result = instance.call("gt_s", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "gt_s", + &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2745,7 +3197,10 @@ fn c313_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 373 fn c314_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c314_l373_action_invoke"); - let result = instance.call("gt_s", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "gt_s", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2753,7 +3208,10 @@ fn c314_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 374 fn c315_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c315_l374_action_invoke"); - let result = instance.call("gt_s", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "gt_s", + &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2761,7 +3219,13 @@ fn c315_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 375 fn c316_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c316_l375_action_invoke"); - let result = instance.call("gt_s", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "gt_s", + &[ + Value::I32(-2147483648 as i32), + Value::I32(2147483647 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2769,7 +3233,13 @@ fn c316_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 376 fn c317_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c317_l376_action_invoke"); - let result = instance.call("gt_s", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "gt_s", + &[ + Value::I32(2147483647 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2801,7 +3271,13 @@ fn c320_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 381 fn c321_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c321_l381_action_invoke"); - let result = instance.call("gt_u", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "gt_u", + &[ + Value::I32(-2147483648 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2809,7 +3285,10 @@ fn c321_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 382 fn c322_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c322_l382_action_invoke"); - let result = instance.call("gt_u", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "gt_u", + &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2841,7 +3320,10 @@ fn c325_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 386 fn c326_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c326_l386_action_invoke"); - let result = instance.call("gt_u", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "gt_u", + &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2849,7 +3331,10 @@ fn c326_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 387 fn c327_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c327_l387_action_invoke"); - let result = instance.call("gt_u", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "gt_u", + &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2857,7 +3342,10 @@ fn c327_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 388 fn c328_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c328_l388_action_invoke"); - let result = instance.call("gt_u", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "gt_u", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2865,7 +3353,10 @@ fn c328_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 389 fn c329_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c329_l389_action_invoke"); - let result = instance.call("gt_u", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "gt_u", + &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2873,7 +3364,13 @@ fn c329_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 390 fn c330_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c330_l390_action_invoke"); - let result = instance.call("gt_u", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "gt_u", + &[ + Value::I32(-2147483648 as i32), + Value::I32(2147483647 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2881,7 +3378,13 @@ fn c330_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 391 fn c331_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c331_l391_action_invoke"); - let result = instance.call("gt_u", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "gt_u", + &[ + Value::I32(2147483647 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2913,7 +3416,13 @@ fn c334_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 396 fn c335_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c335_l396_action_invoke"); - let result = instance.call("ge_s", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "ge_s", + &[ + Value::I32(-2147483648 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2921,7 +3430,10 @@ fn c335_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 397 fn c336_l397_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c336_l397_action_invoke"); - let result = instance.call("ge_s", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "ge_s", + &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2953,7 +3465,10 @@ fn c339_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 401 fn c340_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c340_l401_action_invoke"); - let result = instance.call("ge_s", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "ge_s", + &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2961,7 +3476,10 @@ fn c340_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 402 fn c341_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c341_l402_action_invoke"); - let result = instance.call("ge_s", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "ge_s", + &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2969,7 +3487,10 @@ fn c341_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 403 fn c342_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c342_l403_action_invoke"); - let result = instance.call("ge_s", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "ge_s", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2977,7 +3498,10 @@ fn c342_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 404 fn c343_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c343_l404_action_invoke"); - let result = instance.call("ge_s", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "ge_s", + &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2985,7 +3509,13 @@ fn c343_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 405 fn c344_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c344_l405_action_invoke"); - let result = instance.call("ge_s", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "ge_s", + &[ + Value::I32(-2147483648 as i32), + Value::I32(2147483647 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2993,7 +3523,13 @@ fn c344_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 406 fn c345_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c345_l406_action_invoke"); - let result = instance.call("ge_s", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "ge_s", + &[ + Value::I32(2147483647 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3025,7 +3561,13 @@ fn c348_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 411 fn c349_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c349_l411_action_invoke"); - let result = instance.call("ge_u", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "ge_u", + &[ + Value::I32(-2147483648 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3033,7 +3575,10 @@ fn c349_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 412 fn c350_l412_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c350_l412_action_invoke"); - let result = instance.call("ge_u", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "ge_u", + &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3065,7 +3610,10 @@ fn c353_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 416 fn c354_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c354_l416_action_invoke"); - let result = instance.call("ge_u", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "ge_u", + &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3073,7 +3621,10 @@ fn c354_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 417 fn c355_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c355_l417_action_invoke"); - let result = instance.call("ge_u", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "ge_u", + &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3081,7 +3632,10 @@ fn c355_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 418 fn c356_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c356_l418_action_invoke"); - let result = instance.call("ge_u", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "ge_u", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3089,7 +3643,10 @@ fn c356_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 419 fn c357_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c357_l419_action_invoke"); - let result = instance.call("ge_u", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "ge_u", + &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3097,7 +3654,13 @@ fn c357_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 420 fn c358_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c358_l420_action_invoke"); - let result = instance.call("ge_u", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + let result = instance.call( + "ge_u", + &[ + Value::I32(-2147483648 as i32), + Value::I32(2147483647 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3105,7 +3668,13 @@ fn c358_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 421 fn c359_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c359_l421_action_invoke"); - let result = instance.call("ge_u", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + let result = instance.call( + "ge_u", + &[ + Value::I32(2147483647 as i32), + Value::I32(-2147483648 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } diff --git a/lib/runtime/tests/spectests/i64_.rs b/lib/runtime/tests/spectests/i64_.rs index 4e5abd9ee..32c5d0a89 100644 --- a/lib/runtime/tests/spectests/i64_.rs +++ b/lib/runtime/tests/spectests/i64_.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -168,8 +164,11 @@ fn create_module_1() -> Box { (export \"ge_u\" (func 28))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -212,7 +211,10 @@ fn c4_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 39 fn c5_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c5_l39_action_invoke"); - let result = instance.call("add", &[Value::I64(9223372036854775807 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "add", + &[Value::I64(9223372036854775807 as i64), Value::I64(1 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); result.map(|_| ()) } @@ -220,7 +222,13 @@ fn c5_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 40 fn c6_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c6_l40_action_invoke"); - let result = instance.call("add", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "add", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(9223372036854775807 as i64)))); result.map(|_| ()) } @@ -228,7 +236,13 @@ fn c6_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 41 fn c7_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c7_l41_action_invoke"); - let result = instance.call("add", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "add", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -236,7 +250,10 @@ fn c7_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 42 fn c8_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c8_l42_action_invoke"); - let result = instance.call("add", &[Value::I64(1073741823 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "add", + &[Value::I64(1073741823 as i64), Value::I64(1 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(1073741824 as i64)))); result.map(|_| ()) } @@ -268,7 +285,13 @@ fn c11_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 47 fn c12_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c12_l47_action_invoke"); - let result = instance.call("sub", &[Value::I64(9223372036854775807 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "sub", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); result.map(|_| ()) } @@ -276,7 +299,13 @@ fn c12_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 48 fn c13_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c13_l48_action_invoke"); - let result = instance.call("sub", &[Value::I64(-9223372036854775808 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "sub", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(9223372036854775807 as i64)))); result.map(|_| ()) } @@ -284,7 +313,13 @@ fn c13_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 49 fn c14_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c14_l49_action_invoke"); - let result = instance.call("sub", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "sub", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -292,7 +327,10 @@ fn c14_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 50 fn c15_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c15_l50_action_invoke"); - let result = instance.call("sub", &[Value::I64(1073741823 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "sub", + &[Value::I64(1073741823 as i64), Value::I64(-1 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(1073741824 as i64)))); result.map(|_| ()) } @@ -324,7 +362,13 @@ fn c18_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 55 fn c19_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c19_l55_action_invoke"); - let result = instance.call("mul", &[Value::I64(1152921504606846976 as i64), Value::I64(4096 as i64)]); + let result = instance.call( + "mul", + &[ + Value::I64(1152921504606846976 as i64), + Value::I64(4096 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -332,7 +376,13 @@ fn c19_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 56 fn c20_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c20_l56_action_invoke"); - let result = instance.call("mul", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "mul", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(0 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -340,7 +390,13 @@ fn c20_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 57 fn c21_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c21_l57_action_invoke"); - let result = instance.call("mul", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "mul", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); result.map(|_| ()) } @@ -348,7 +404,13 @@ fn c21_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 58 fn c22_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c22_l58_action_invoke"); - let result = instance.call("mul", &[Value::I64(9223372036854775807 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "mul", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-9223372036854775807 as i64)))); result.map(|_| ()) } @@ -356,7 +418,13 @@ fn c22_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 59 fn c23_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c23_l59_action_invoke"); - let result = instance.call("mul", &[Value::I64(81985529216486895 as i64), Value::I64(-81985529216486896 as i64)]); + let result = instance.call( + "mul", + &[ + Value::I64(81985529216486895 as i64), + Value::I64(-81985529216486896 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(2465395958572223728 as i64)))); result.map(|_| ()) } @@ -364,7 +432,13 @@ fn c23_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 60 fn c24_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c24_l60_action_invoke"); - let result = instance.call("mul", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "mul", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); result.map(|_| ()) } @@ -373,14 +447,14 @@ fn c24_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c25_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c25_l62_action_invoke"); let result = instance.call("div_s", &[Value::I64(1 as i64), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c25_l62_assert_trap() { let mut instance = create_module_1(); - let result = c25_l62_action_invoke(&mut*instance); + let result = c25_l62_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -388,29 +462,35 @@ fn c25_l62_assert_trap() { fn c26_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c26_l63_action_invoke"); let result = instance.call("div_s", &[Value::I64(0 as i64), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c26_l63_assert_trap() { let mut instance = create_module_1(); - let result = c26_l63_action_invoke(&mut*instance); + let result = c26_l63_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 64 fn c27_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c27_l64_action_invoke"); - let result = instance.call("div_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); - + let result = instance.call( + "div_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); + result.map(|_| ()) } #[test] fn c27_l64_assert_trap() { let mut instance = create_module_1(); - let result = c27_l64_action_invoke(&mut*instance); + let result = c27_l64_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -449,7 +529,13 @@ fn c31_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 69 fn c32_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c32_l69_action_invoke"); - let result = instance.call("div_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(2 as i64)]); + let result = instance.call( + "div_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(2 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-4611686018427387904 as i64)))); result.map(|_| ()) } @@ -457,7 +543,13 @@ fn c32_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 70 fn c33_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c33_l70_action_invoke"); - let result = instance.call("div_s", &[Value::I64(-9223372036854775807 as i64), Value::I64(1000 as i64)]); + let result = instance.call( + "div_s", + &[ + Value::I64(-9223372036854775807 as i64), + Value::I64(1000 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-9223372036854775 as i64)))); result.map(|_| ()) } @@ -546,14 +638,14 @@ fn c43_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c44_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c44_l82_action_invoke"); let result = instance.call("div_u", &[Value::I64(1 as i64), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c44_l82_assert_trap() { let mut instance = create_module_1(); - let result = c44_l82_action_invoke(&mut*instance); + let result = c44_l82_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -561,14 +653,14 @@ fn c44_l82_assert_trap() { fn c45_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c45_l83_action_invoke"); let result = instance.call("div_u", &[Value::I64(0 as i64), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c45_l83_assert_trap() { let mut instance = create_module_1(); - let result = c45_l83_action_invoke(&mut*instance); + let result = c45_l83_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -599,7 +691,13 @@ fn c48_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 87 fn c49_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c49_l87_action_invoke"); - let result = instance.call("div_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "div_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -607,7 +705,13 @@ fn c49_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 88 fn c50_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c50_l88_action_invoke"); - let result = instance.call("div_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(2 as i64)]); + let result = instance.call( + "div_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(2 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(4611686018427387904 as i64)))); result.map(|_| ()) } @@ -615,7 +719,13 @@ fn c50_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 89 fn c51_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c51_l89_action_invoke"); - let result = instance.call("div_u", &[Value::I64(-8074936608141340688 as i64), Value::I64(4294967297 as i64)]); + let result = instance.call( + "div_u", + &[ + Value::I64(-8074936608141340688 as i64), + Value::I64(4294967297 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(2414874607 as i64)))); result.map(|_| ()) } @@ -623,7 +733,13 @@ fn c51_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 90 fn c52_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c52_l90_action_invoke"); - let result = instance.call("div_u", &[Value::I64(-9223372036854775807 as i64), Value::I64(1000 as i64)]); + let result = instance.call( + "div_u", + &[ + Value::I64(-9223372036854775807 as i64), + Value::I64(1000 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(9223372036854775 as i64)))); result.map(|_| ()) } @@ -688,14 +804,14 @@ fn c59_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c60_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c60_l99_action_invoke"); let result = instance.call("rem_s", &[Value::I64(1 as i64), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c60_l99_assert_trap() { let mut instance = create_module_1(); - let result = c60_l99_action_invoke(&mut*instance); + let result = c60_l99_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -703,21 +819,27 @@ fn c60_l99_assert_trap() { fn c61_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c61_l100_action_invoke"); let result = instance.call("rem_s", &[Value::I64(0 as i64), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c61_l100_assert_trap() { let mut instance = create_module_1(); - let result = c61_l100_action_invoke(&mut*instance); + let result = c61_l100_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 101 fn c62_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c62_l101_action_invoke"); - let result = instance.call("rem_s", &[Value::I64(9223372036854775807 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "rem_s", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -757,7 +879,13 @@ fn c66_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 106 fn c67_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c67_l106_action_invoke"); - let result = instance.call("rem_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "rem_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -765,7 +893,13 @@ fn c67_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 107 fn c68_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c68_l107_action_invoke"); - let result = instance.call("rem_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(2 as i64)]); + let result = instance.call( + "rem_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(2 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -773,7 +907,13 @@ fn c68_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 108 fn c69_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c69_l108_action_invoke"); - let result = instance.call("rem_s", &[Value::I64(-9223372036854775807 as i64), Value::I64(1000 as i64)]); + let result = instance.call( + "rem_s", + &[ + Value::I64(-9223372036854775807 as i64), + Value::I64(1000 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-807 as i64)))); result.map(|_| ()) } @@ -862,14 +1002,14 @@ fn c79_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c80_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c80_l120_action_invoke"); let result = instance.call("rem_u", &[Value::I64(1 as i64), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c80_l120_assert_trap() { let mut instance = create_module_1(); - let result = c80_l120_action_invoke(&mut*instance); + let result = c80_l120_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -877,14 +1017,14 @@ fn c80_l120_assert_trap() { fn c81_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c81_l121_action_invoke"); let result = instance.call("rem_u", &[Value::I64(0 as i64), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c81_l121_assert_trap() { let mut instance = create_module_1(); - let result = c81_l121_action_invoke(&mut*instance); + let result = c81_l121_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -915,7 +1055,13 @@ fn c84_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 125 fn c85_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c85_l125_action_invoke"); - let result = instance.call("rem_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "rem_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); result.map(|_| ()) } @@ -923,7 +1069,13 @@ fn c85_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 126 fn c86_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c86_l126_action_invoke"); - let result = instance.call("rem_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(2 as i64)]); + let result = instance.call( + "rem_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(2 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -931,7 +1083,13 @@ fn c86_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 127 fn c87_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c87_l127_action_invoke"); - let result = instance.call("rem_u", &[Value::I64(-8074936608141340688 as i64), Value::I64(4294967297 as i64)]); + let result = instance.call( + "rem_u", + &[ + Value::I64(-8074936608141340688 as i64), + Value::I64(4294967297 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(2147483649 as i64)))); result.map(|_| ()) } @@ -939,7 +1097,13 @@ fn c87_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 128 fn c88_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c88_l128_action_invoke"); - let result = instance.call("rem_u", &[Value::I64(-9223372036854775807 as i64), Value::I64(1000 as i64)]); + let result = instance.call( + "rem_u", + &[ + Value::I64(-9223372036854775807 as i64), + Value::I64(1000 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(809 as i64)))); result.map(|_| ()) } @@ -1035,7 +1199,13 @@ fn c99_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 141 fn c100_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c100_l141_action_invoke"); - let result = instance.call("and", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "and", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -1043,7 +1213,13 @@ fn c100_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 142 fn c101_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c101_l142_action_invoke"); - let result = instance.call("and", &[Value::I64(9223372036854775807 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "and", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(9223372036854775807 as i64)))); result.map(|_| ()) } @@ -1051,7 +1227,10 @@ fn c101_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 143 fn c102_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c102_l143_action_invoke"); - let result = instance.call("and", &[Value::I64(4042326015 as i64), Value::I64(4294963440 as i64)]); + let result = instance.call( + "and", + &[Value::I64(4042326015 as i64), Value::I64(4294963440 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(4042322160 as i64)))); result.map(|_| ()) } @@ -1099,7 +1278,13 @@ fn c107_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 150 fn c108_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c108_l150_action_invoke"); - let result = instance.call("or", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "or", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); result.map(|_| ()) } @@ -1107,7 +1292,13 @@ fn c108_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 151 fn c109_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c109_l151_action_invoke"); - let result = instance.call("or", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "or", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(0 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); result.map(|_| ()) } @@ -1115,7 +1306,10 @@ fn c109_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 152 fn c110_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c110_l152_action_invoke"); - let result = instance.call("or", &[Value::I64(4042326015 as i64), Value::I64(4294963440 as i64)]); + let result = instance.call( + "or", + &[Value::I64(4042326015 as i64), Value::I64(4294963440 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(4294967295 as i64)))); result.map(|_| ()) } @@ -1163,7 +1357,13 @@ fn c115_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 159 fn c116_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c116_l159_action_invoke"); - let result = instance.call("xor", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "xor", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); result.map(|_| ()) } @@ -1171,7 +1371,13 @@ fn c116_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 160 fn c117_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c117_l160_action_invoke"); - let result = instance.call("xor", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "xor", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(0 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); result.map(|_| ()) } @@ -1179,7 +1385,13 @@ fn c117_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 161 fn c118_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c118_l161_action_invoke"); - let result = instance.call("xor", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "xor", + &[ + Value::I64(-1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(9223372036854775807 as i64)))); result.map(|_| ()) } @@ -1187,7 +1399,13 @@ fn c118_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 162 fn c119_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c119_l162_action_invoke"); - let result = instance.call("xor", &[Value::I64(-1 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "xor", + &[ + Value::I64(-1 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); result.map(|_| ()) } @@ -1195,7 +1413,10 @@ fn c119_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 163 fn c120_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c120_l163_action_invoke"); - let result = instance.call("xor", &[Value::I64(4042326015 as i64), Value::I64(4294963440 as i64)]); + let result = instance.call( + "xor", + &[Value::I64(4042326015 as i64), Value::I64(4294963440 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(252645135 as i64)))); result.map(|_| ()) } @@ -1227,7 +1448,10 @@ fn c123_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 168 fn c124_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c124_l168_action_invoke"); - let result = instance.call("shl", &[Value::I64(9223372036854775807 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "shl", + &[Value::I64(9223372036854775807 as i64), Value::I64(1 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(-2 as i64)))); result.map(|_| ()) } @@ -1243,7 +1467,13 @@ fn c125_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 170 fn c126_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c126_l170_action_invoke"); - let result = instance.call("shl", &[Value::I64(-9223372036854775808 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "shl", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -1251,7 +1481,10 @@ fn c126_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 171 fn c127_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c127_l171_action_invoke"); - let result = instance.call("shl", &[Value::I64(4611686018427387904 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "shl", + &[Value::I64(4611686018427387904 as i64), Value::I64(1 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); result.map(|_| ()) } @@ -1291,7 +1524,10 @@ fn c131_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 176 fn c132_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c132_l176_action_invoke"); - let result = instance.call("shl", &[Value::I64(1 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "shl", + &[Value::I64(1 as i64), Value::I64(9223372036854775807 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); result.map(|_| ()) } @@ -1323,7 +1559,10 @@ fn c135_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 181 fn c136_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c136_l181_action_invoke"); - let result = instance.call("shr_s", &[Value::I64(9223372036854775807 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "shr_s", + &[Value::I64(9223372036854775807 as i64), Value::I64(1 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(4611686018427387903 as i64)))); result.map(|_| ()) } @@ -1331,7 +1570,13 @@ fn c136_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 182 fn c137_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c137_l182_action_invoke"); - let result = instance.call("shr_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "shr_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-4611686018427387904 as i64)))); result.map(|_| ()) } @@ -1339,7 +1584,10 @@ fn c137_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 183 fn c138_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c138_l183_action_invoke"); - let result = instance.call("shr_s", &[Value::I64(4611686018427387904 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "shr_s", + &[Value::I64(4611686018427387904 as i64), Value::I64(1 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(2305843009213693952 as i64)))); result.map(|_| ()) } @@ -1371,7 +1619,10 @@ fn c141_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 187 fn c142_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c142_l187_action_invoke"); - let result = instance.call("shr_s", &[Value::I64(1 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "shr_s", + &[Value::I64(1 as i64), Value::I64(9223372036854775807 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -1379,7 +1630,13 @@ fn c142_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 188 fn c143_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c143_l188_action_invoke"); - let result = instance.call("shr_s", &[Value::I64(1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "shr_s", + &[ + Value::I64(1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); result.map(|_| ()) } @@ -1387,7 +1644,13 @@ fn c143_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 189 fn c144_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c144_l189_action_invoke"); - let result = instance.call("shr_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(63 as i64)]); + let result = instance.call( + "shr_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(63 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); result.map(|_| ()) } @@ -1419,7 +1682,13 @@ fn c147_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 193 fn c148_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c148_l193_action_invoke"); - let result = instance.call("shr_s", &[Value::I64(-1 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "shr_s", + &[ + Value::I64(-1 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); result.map(|_| ()) } @@ -1427,7 +1696,13 @@ fn c148_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 194 fn c149_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c149_l194_action_invoke"); - let result = instance.call("shr_s", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "shr_s", + &[ + Value::I64(-1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); result.map(|_| ()) } @@ -1459,7 +1734,10 @@ fn c152_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 199 fn c153_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c153_l199_action_invoke"); - let result = instance.call("shr_u", &[Value::I64(9223372036854775807 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "shr_u", + &[Value::I64(9223372036854775807 as i64), Value::I64(1 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(4611686018427387903 as i64)))); result.map(|_| ()) } @@ -1467,7 +1745,13 @@ fn c153_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 200 fn c154_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c154_l200_action_invoke"); - let result = instance.call("shr_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "shr_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(4611686018427387904 as i64)))); result.map(|_| ()) } @@ -1475,7 +1759,10 @@ fn c154_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 201 fn c155_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c155_l201_action_invoke"); - let result = instance.call("shr_u", &[Value::I64(4611686018427387904 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "shr_u", + &[Value::I64(4611686018427387904 as i64), Value::I64(1 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(2305843009213693952 as i64)))); result.map(|_| ()) } @@ -1507,7 +1794,10 @@ fn c158_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 205 fn c159_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c159_l205_action_invoke"); - let result = instance.call("shr_u", &[Value::I64(1 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "shr_u", + &[Value::I64(1 as i64), Value::I64(9223372036854775807 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -1515,7 +1805,13 @@ fn c159_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 206 fn c160_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c160_l206_action_invoke"); - let result = instance.call("shr_u", &[Value::I64(1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "shr_u", + &[ + Value::I64(1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); result.map(|_| ()) } @@ -1523,7 +1819,13 @@ fn c160_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 207 fn c161_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c161_l207_action_invoke"); - let result = instance.call("shr_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(63 as i64)]); + let result = instance.call( + "shr_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(63 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); result.map(|_| ()) } @@ -1555,7 +1857,13 @@ fn c164_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 211 fn c165_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c165_l211_action_invoke"); - let result = instance.call("shr_u", &[Value::I64(-1 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "shr_u", + &[ + Value::I64(-1 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); result.map(|_| ()) } @@ -1563,7 +1871,13 @@ fn c165_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 212 fn c166_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c166_l212_action_invoke"); - let result = instance.call("shr_u", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "shr_u", + &[ + Value::I64(-1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); result.map(|_| ()) } @@ -1603,7 +1917,13 @@ fn c170_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 218 fn c171_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c171_l218_action_invoke"); - let result = instance.call("rotl", &[Value::I64(-6067025490386449714 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "rotl", + &[ + Value::I64(-6067025490386449714 as i64), + Value::I64(1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(6312693092936652189 as i64)))); result.map(|_| ()) } @@ -1611,7 +1931,10 @@ fn c171_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 219 fn c172_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c172_l219_action_invoke"); - let result = instance.call("rotl", &[Value::I64(-144115184384868352 as i64), Value::I64(4 as i64)]); + let result = instance.call( + "rotl", + &[Value::I64(-144115184384868352 as i64), Value::I64(4 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(-2305842950157893617 as i64)))); result.map(|_| ()) } @@ -1619,7 +1942,13 @@ fn c172_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 220 fn c173_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c173_l220_action_invoke"); - let result = instance.call("rotl", &[Value::I64(-6067173104435169271 as i64), Value::I64(53 as i64)]); + let result = instance.call( + "rotl", + &[ + Value::I64(-6067173104435169271 as i64), + Value::I64(53 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(87109505680009935 as i64)))); result.map(|_| ()) } @@ -1627,7 +1956,13 @@ fn c173_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 221 fn c174_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c174_l221_action_invoke"); - let result = instance.call("rotl", &[Value::I64(-6066028401059725156 as i64), Value::I64(63 as i64)]); + let result = instance.call( + "rotl", + &[ + Value::I64(-6066028401059725156 as i64), + Value::I64(63 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(6190357836324913230 as i64)))); result.map(|_| ()) } @@ -1635,7 +1970,13 @@ fn c174_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 222 fn c175_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c175_l222_action_invoke"); - let result = instance.call("rotl", &[Value::I64(-6067173104435169271 as i64), Value::I64(245 as i64)]); + let result = instance.call( + "rotl", + &[ + Value::I64(-6067173104435169271 as i64), + Value::I64(245 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(87109505680009935 as i64)))); result.map(|_| ()) } @@ -1643,7 +1984,13 @@ fn c175_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 223 fn c176_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c176_l223_action_invoke"); - let result = instance.call("rotl", &[Value::I64(-6067067139002042359 as i64), Value::I64(-19 as i64)]); + let result = instance.call( + "rotl", + &[ + Value::I64(-6067067139002042359 as i64), + Value::I64(-19 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-3530481836149793302 as i64)))); result.map(|_| ()) } @@ -1651,7 +1998,13 @@ fn c176_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 224 fn c177_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c177_l224_action_invoke"); - let result = instance.call("rotl", &[Value::I64(-6066028401059725156 as i64), Value::I64(-9223372036854775745 as i64)]); + let result = instance.call( + "rotl", + &[ + Value::I64(-6066028401059725156 as i64), + Value::I64(-9223372036854775745 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(6190357836324913230 as i64)))); result.map(|_| ()) } @@ -1667,7 +2020,13 @@ fn c178_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 226 fn c179_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c179_l226_action_invoke"); - let result = instance.call("rotl", &[Value::I64(-9223372036854775808 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "rotl", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); result.map(|_| ()) } @@ -1707,7 +2066,13 @@ fn c183_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 232 fn c184_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c184_l232_action_invoke"); - let result = instance.call("rotr", &[Value::I64(-6067025490386449714 as i64), Value::I64(1 as i64)]); + let result = instance.call( + "rotr", + &[ + Value::I64(-6067025490386449714 as i64), + Value::I64(1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(6189859291661550951 as i64)))); result.map(|_| ()) } @@ -1715,7 +2080,10 @@ fn c184_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 233 fn c185_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c185_l233_action_invoke"); - let result = instance.call("rotr", &[Value::I64(-144115184384868352 as i64), Value::I64(4 as i64)]); + let result = instance.call( + "rotr", + &[Value::I64(-144115184384868352 as i64), Value::I64(4 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(1143914305582792704 as i64)))); result.map(|_| ()) } @@ -1723,7 +2091,13 @@ fn c185_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 234 fn c186_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c186_l234_action_invoke"); - let result = instance.call("rotr", &[Value::I64(-6067173104435169271 as i64), Value::I64(53 as i64)]); + let result = instance.call( + "rotr", + &[ + Value::I64(-6067173104435169271 as i64), + Value::I64(53 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(7534987797011123550 as i64)))); result.map(|_| ()) } @@ -1731,7 +2105,13 @@ fn c186_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 235 fn c187_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c187_l235_action_invoke"); - let result = instance.call("rotr", &[Value::I64(-6066028401059725156 as i64), Value::I64(63 as i64)]); + let result = instance.call( + "rotr", + &[ + Value::I64(-6066028401059725156 as i64), + Value::I64(63 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(6314687271590101305 as i64)))); result.map(|_| ()) } @@ -1739,7 +2119,13 @@ fn c187_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 236 fn c188_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c188_l236_action_invoke"); - let result = instance.call("rotr", &[Value::I64(-6067173104435169271 as i64), Value::I64(245 as i64)]); + let result = instance.call( + "rotr", + &[ + Value::I64(-6067173104435169271 as i64), + Value::I64(245 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(7534987797011123550 as i64)))); result.map(|_| ()) } @@ -1747,7 +2133,13 @@ fn c188_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 237 fn c189_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c189_l237_action_invoke"); - let result = instance.call("rotr", &[Value::I64(-6067067139002042359 as i64), Value::I64(-19 as i64)]); + let result = instance.call( + "rotr", + &[ + Value::I64(-6067067139002042359 as i64), + Value::I64(-19 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(-7735078922541506965 as i64)))); result.map(|_| ()) } @@ -1755,7 +2147,13 @@ fn c189_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 238 fn c190_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c190_l238_action_invoke"); - let result = instance.call("rotr", &[Value::I64(-6066028401059725156 as i64), Value::I64(-9223372036854775745 as i64)]); + let result = instance.call( + "rotr", + &[ + Value::I64(-6066028401059725156 as i64), + Value::I64(-9223372036854775745 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(6314687271590101305 as i64)))); result.map(|_| ()) } @@ -1771,7 +2169,13 @@ fn c191_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 240 fn c192_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c192_l240_action_invoke"); - let result = instance.call("rotr", &[Value::I64(-9223372036854775808 as i64), Value::I64(63 as i64)]); + let result = instance.call( + "rotr", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(63 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); result.map(|_| ()) } @@ -2019,7 +2423,13 @@ fn c222_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 276 fn c223_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c223_l276_action_invoke"); - let result = instance.call("eq", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "eq", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2027,7 +2437,13 @@ fn c223_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 277 fn c224_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c224_l277_action_invoke"); - let result = instance.call("eq", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "eq", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2059,7 +2475,13 @@ fn c227_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 281 fn c228_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c228_l281_action_invoke"); - let result = instance.call("eq", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "eq", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(0 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2067,7 +2489,13 @@ fn c228_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 282 fn c229_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c229_l282_action_invoke"); - let result = instance.call("eq", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "eq", + &[ + Value::I64(0 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2075,7 +2503,13 @@ fn c229_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 283 fn c230_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c230_l283_action_invoke"); - let result = instance.call("eq", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "eq", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2083,7 +2517,13 @@ fn c230_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 284 fn c231_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c231_l284_action_invoke"); - let result = instance.call("eq", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "eq", + &[ + Value::I64(-1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2091,7 +2531,13 @@ fn c231_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 285 fn c232_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c232_l285_action_invoke"); - let result = instance.call("eq", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "eq", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2099,7 +2545,13 @@ fn c232_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 286 fn c233_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c233_l286_action_invoke"); - let result = instance.call("eq", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "eq", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2131,7 +2583,13 @@ fn c236_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 291 fn c237_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c237_l291_action_invoke"); - let result = instance.call("ne", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "ne", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2139,7 +2597,13 @@ fn c237_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 292 fn c238_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c238_l292_action_invoke"); - let result = instance.call("ne", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "ne", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2171,7 +2635,13 @@ fn c241_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 296 fn c242_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c242_l296_action_invoke"); - let result = instance.call("ne", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "ne", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(0 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2179,7 +2649,13 @@ fn c242_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 297 fn c243_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c243_l297_action_invoke"); - let result = instance.call("ne", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "ne", + &[ + Value::I64(0 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2187,7 +2663,13 @@ fn c243_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 298 fn c244_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c244_l298_action_invoke"); - let result = instance.call("ne", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "ne", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2195,7 +2677,13 @@ fn c244_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 299 fn c245_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c245_l299_action_invoke"); - let result = instance.call("ne", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "ne", + &[ + Value::I64(-1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2203,7 +2691,13 @@ fn c245_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 300 fn c246_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c246_l300_action_invoke"); - let result = instance.call("ne", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "ne", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2211,7 +2705,13 @@ fn c246_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 301 fn c247_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c247_l301_action_invoke"); - let result = instance.call("ne", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "ne", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2243,7 +2743,13 @@ fn c250_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 306 fn c251_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c251_l306_action_invoke"); - let result = instance.call("lt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "lt_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2251,7 +2757,13 @@ fn c251_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 307 fn c252_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c252_l307_action_invoke"); - let result = instance.call("lt_s", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "lt_s", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2283,7 +2795,13 @@ fn c255_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 311 fn c256_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c256_l311_action_invoke"); - let result = instance.call("lt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "lt_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(0 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2291,7 +2809,13 @@ fn c256_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 312 fn c257_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c257_l312_action_invoke"); - let result = instance.call("lt_s", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "lt_s", + &[ + Value::I64(0 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2299,7 +2823,13 @@ fn c257_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 313 fn c258_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c258_l313_action_invoke"); - let result = instance.call("lt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "lt_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2307,7 +2837,13 @@ fn c258_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 314 fn c259_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c259_l314_action_invoke"); - let result = instance.call("lt_s", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "lt_s", + &[ + Value::I64(-1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2315,7 +2851,13 @@ fn c259_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 315 fn c260_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c260_l315_action_invoke"); - let result = instance.call("lt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "lt_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2323,7 +2865,13 @@ fn c260_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 316 fn c261_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c261_l316_action_invoke"); - let result = instance.call("lt_s", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "lt_s", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2355,7 +2903,13 @@ fn c264_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 321 fn c265_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c265_l321_action_invoke"); - let result = instance.call("lt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "lt_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2363,7 +2917,13 @@ fn c265_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 322 fn c266_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c266_l322_action_invoke"); - let result = instance.call("lt_u", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "lt_u", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2395,7 +2955,13 @@ fn c269_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 326 fn c270_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c270_l326_action_invoke"); - let result = instance.call("lt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "lt_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(0 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2403,7 +2969,13 @@ fn c270_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 327 fn c271_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c271_l327_action_invoke"); - let result = instance.call("lt_u", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "lt_u", + &[ + Value::I64(0 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2411,7 +2983,13 @@ fn c271_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 328 fn c272_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c272_l328_action_invoke"); - let result = instance.call("lt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "lt_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2419,7 +2997,13 @@ fn c272_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 329 fn c273_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c273_l329_action_invoke"); - let result = instance.call("lt_u", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "lt_u", + &[ + Value::I64(-1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2427,7 +3011,13 @@ fn c273_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 330 fn c274_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c274_l330_action_invoke"); - let result = instance.call("lt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "lt_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2435,7 +3025,13 @@ fn c274_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 331 fn c275_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c275_l331_action_invoke"); - let result = instance.call("lt_u", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "lt_u", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2467,7 +3063,13 @@ fn c278_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 336 fn c279_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c279_l336_action_invoke"); - let result = instance.call("le_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "le_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2475,7 +3077,13 @@ fn c279_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 337 fn c280_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c280_l337_action_invoke"); - let result = instance.call("le_s", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "le_s", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2507,7 +3115,13 @@ fn c283_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 341 fn c284_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c284_l341_action_invoke"); - let result = instance.call("le_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "le_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(0 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2515,7 +3129,13 @@ fn c284_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 342 fn c285_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c285_l342_action_invoke"); - let result = instance.call("le_s", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "le_s", + &[ + Value::I64(0 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2523,7 +3143,13 @@ fn c285_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 343 fn c286_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c286_l343_action_invoke"); - let result = instance.call("le_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "le_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2531,7 +3157,13 @@ fn c286_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 344 fn c287_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c287_l344_action_invoke"); - let result = instance.call("le_s", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "le_s", + &[ + Value::I64(-1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2539,7 +3171,13 @@ fn c287_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 345 fn c288_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c288_l345_action_invoke"); - let result = instance.call("le_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "le_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2547,7 +3185,13 @@ fn c288_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 346 fn c289_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c289_l346_action_invoke"); - let result = instance.call("le_s", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "le_s", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2579,7 +3223,13 @@ fn c292_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 351 fn c293_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c293_l351_action_invoke"); - let result = instance.call("le_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "le_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2587,7 +3237,13 @@ fn c293_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 352 fn c294_l352_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c294_l352_action_invoke"); - let result = instance.call("le_u", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "le_u", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2619,7 +3275,13 @@ fn c297_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 356 fn c298_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c298_l356_action_invoke"); - let result = instance.call("le_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "le_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(0 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2627,7 +3289,13 @@ fn c298_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 357 fn c299_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c299_l357_action_invoke"); - let result = instance.call("le_u", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "le_u", + &[ + Value::I64(0 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2635,7 +3303,13 @@ fn c299_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 358 fn c300_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c300_l358_action_invoke"); - let result = instance.call("le_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "le_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2643,7 +3317,13 @@ fn c300_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 359 fn c301_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c301_l359_action_invoke"); - let result = instance.call("le_u", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "le_u", + &[ + Value::I64(-1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2651,7 +3331,13 @@ fn c301_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 360 fn c302_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c302_l360_action_invoke"); - let result = instance.call("le_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "le_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2659,7 +3345,13 @@ fn c302_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 361 fn c303_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c303_l361_action_invoke"); - let result = instance.call("le_u", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "le_u", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2691,7 +3383,13 @@ fn c306_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 366 fn c307_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c307_l366_action_invoke"); - let result = instance.call("gt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "gt_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2699,7 +3397,13 @@ fn c307_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 367 fn c308_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c308_l367_action_invoke"); - let result = instance.call("gt_s", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "gt_s", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2731,7 +3435,13 @@ fn c311_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 371 fn c312_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c312_l371_action_invoke"); - let result = instance.call("gt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "gt_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(0 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2739,7 +3449,13 @@ fn c312_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 372 fn c313_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c313_l372_action_invoke"); - let result = instance.call("gt_s", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "gt_s", + &[ + Value::I64(0 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2747,7 +3463,13 @@ fn c313_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 373 fn c314_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c314_l373_action_invoke"); - let result = instance.call("gt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "gt_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2755,7 +3477,13 @@ fn c314_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 374 fn c315_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c315_l374_action_invoke"); - let result = instance.call("gt_s", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "gt_s", + &[ + Value::I64(-1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2763,7 +3491,13 @@ fn c315_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 375 fn c316_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c316_l375_action_invoke"); - let result = instance.call("gt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "gt_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2771,7 +3505,13 @@ fn c316_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 376 fn c317_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c317_l376_action_invoke"); - let result = instance.call("gt_s", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "gt_s", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2803,7 +3543,13 @@ fn c320_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 381 fn c321_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c321_l381_action_invoke"); - let result = instance.call("gt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "gt_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2811,7 +3557,13 @@ fn c321_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 382 fn c322_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c322_l382_action_invoke"); - let result = instance.call("gt_u", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "gt_u", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2843,7 +3595,13 @@ fn c325_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 386 fn c326_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c326_l386_action_invoke"); - let result = instance.call("gt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "gt_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(0 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2851,7 +3609,13 @@ fn c326_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 387 fn c327_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c327_l387_action_invoke"); - let result = instance.call("gt_u", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "gt_u", + &[ + Value::I64(0 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2859,7 +3623,13 @@ fn c327_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 388 fn c328_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c328_l388_action_invoke"); - let result = instance.call("gt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "gt_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2867,7 +3637,13 @@ fn c328_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 389 fn c329_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c329_l389_action_invoke"); - let result = instance.call("gt_u", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "gt_u", + &[ + Value::I64(-1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2875,7 +3651,13 @@ fn c329_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 390 fn c330_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c330_l390_action_invoke"); - let result = instance.call("gt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "gt_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2883,7 +3665,13 @@ fn c330_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 391 fn c331_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c331_l391_action_invoke"); - let result = instance.call("gt_u", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "gt_u", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2915,7 +3703,13 @@ fn c334_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 396 fn c335_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c335_l396_action_invoke"); - let result = instance.call("ge_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "ge_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2923,7 +3717,13 @@ fn c335_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 397 fn c336_l397_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c336_l397_action_invoke"); - let result = instance.call("ge_s", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "ge_s", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2955,7 +3755,13 @@ fn c339_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 401 fn c340_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c340_l401_action_invoke"); - let result = instance.call("ge_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "ge_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(0 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2963,7 +3769,13 @@ fn c340_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 402 fn c341_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c341_l402_action_invoke"); - let result = instance.call("ge_s", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "ge_s", + &[ + Value::I64(0 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2971,7 +3783,13 @@ fn c341_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 403 fn c342_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c342_l403_action_invoke"); - let result = instance.call("ge_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "ge_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2979,7 +3797,13 @@ fn c342_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 404 fn c343_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c343_l404_action_invoke"); - let result = instance.call("ge_s", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "ge_s", + &[ + Value::I64(-1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -2987,7 +3811,13 @@ fn c343_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 405 fn c344_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c344_l405_action_invoke"); - let result = instance.call("ge_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "ge_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -2995,7 +3825,13 @@ fn c344_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 406 fn c345_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c345_l406_action_invoke"); - let result = instance.call("ge_s", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "ge_s", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3027,7 +3863,13 @@ fn c348_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 411 fn c349_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c349_l411_action_invoke"); - let result = instance.call("ge_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "ge_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3035,7 +3877,13 @@ fn c349_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 412 fn c350_l412_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c350_l412_action_invoke"); - let result = instance.call("ge_u", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "ge_u", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3067,7 +3915,13 @@ fn c353_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 416 fn c354_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c354_l416_action_invoke"); - let result = instance.call("ge_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "ge_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(0 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3075,7 +3929,13 @@ fn c354_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 417 fn c355_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c355_l417_action_invoke"); - let result = instance.call("ge_u", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "ge_u", + &[ + Value::I64(0 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3083,7 +3943,13 @@ fn c355_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 418 fn c356_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c356_l418_action_invoke"); - let result = instance.call("ge_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + let result = instance.call( + "ge_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -3091,7 +3957,13 @@ fn c356_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 419 fn c357_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c357_l419_action_invoke"); - let result = instance.call("ge_u", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "ge_u", + &[ + Value::I64(-1 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3099,7 +3971,13 @@ fn c357_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 420 fn c358_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c358_l420_action_invoke"); - let result = instance.call("ge_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + let result = instance.call( + "ge_u", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(9223372036854775807 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -3107,7 +3985,13 @@ fn c358_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 421 fn c359_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c359_l421_action_invoke"); - let result = instance.call("ge_u", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "ge_u", + &[ + Value::I64(9223372036854775807 as i64), + Value::I64(-9223372036854775808 as i64), + ], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } diff --git a/lib/runtime/tests/spectests/if_.rs b/lib/runtime/tests/spectests/if_.rs index dd82d8181..d5388e1f8 100644 --- a/lib/runtime/tests/spectests/if_.rs +++ b/lib/runtime/tests/spectests/if_.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -641,8 +637,11 @@ fn create_module_1() -> Box { (elem (;0;) (i32.const 0) 16)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -1030,14 +1029,14 @@ fn c47_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c48_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c48_l440_action_invoke"); let result = instance.call("as-call_indirect-last", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c48_l440_assert_trap() { let mut instance = create_module_1(); - let result = c48_l440_action_invoke(&mut*instance); + let result = c48_l440_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1244,7 +1243,10 @@ fn c73_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 478 fn c74_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c74_l478_action_invoke"); - let result = instance.call("as-binary-operand", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "as-binary-operand", + &[Value::I32(0 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(15 as i32)))); result.map(|_| ()) } @@ -1252,7 +1254,10 @@ fn c74_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 479 fn c75_l479_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c75_l479_action_invoke"); - let result = instance.call("as-binary-operand", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "as-binary-operand", + &[Value::I32(0 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-12 as i32)))); result.map(|_| ()) } @@ -1260,7 +1265,10 @@ fn c75_l479_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 480 fn c76_l480_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c76_l480_action_invoke"); - let result = instance.call("as-binary-operand", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "as-binary-operand", + &[Value::I32(1 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(-15 as i32)))); result.map(|_| ()) } @@ -1268,7 +1276,10 @@ fn c76_l480_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 481 fn c77_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c77_l481_action_invoke"); - let result = instance.call("as-binary-operand", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "as-binary-operand", + &[Value::I32(1 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(12 as i32)))); result.map(|_| ()) } @@ -1292,7 +1303,10 @@ fn c79_l484_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 486 fn c80_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c80_l486_action_invoke"); - let result = instance.call("as-compare-operand", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "as-compare-operand", + &[Value::I32(0 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1300,7 +1314,10 @@ fn c80_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 487 fn c81_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c81_l487_action_invoke"); - let result = instance.call("as-compare-operand", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "as-compare-operand", + &[Value::I32(0 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1308,7 +1325,10 @@ fn c81_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 488 fn c82_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c82_l488_action_invoke"); - let result = instance.call("as-compare-operand", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "as-compare-operand", + &[Value::I32(1 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1316,7 +1336,10 @@ fn c82_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 489 fn c83_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c83_l489_action_invoke"); - let result = instance.call("as-compare-operand", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "as-compare-operand", + &[Value::I32(1 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -1364,7 +1387,10 @@ fn c88_l496_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 499 #[test] fn c89_l499_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, + 64, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1372,7 +1398,10 @@ fn c89_l499_assert_invalid() { // Line 503 #[test] fn c90_l503_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, + 64, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1380,7 +1409,10 @@ fn c90_l503_assert_invalid() { // Line 507 #[test] fn c91_l507_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, + 64, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1388,7 +1420,10 @@ fn c91_l507_assert_invalid() { // Line 511 #[test] fn c92_l511_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, + 64, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1396,7 +1431,10 @@ fn c92_l511_assert_invalid() { // Line 516 #[test] fn c93_l516_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, + 64, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1404,7 +1442,10 @@ fn c93_l516_assert_invalid() { // Line 520 #[test] fn c94_l520_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, + 64, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1412,7 +1453,10 @@ fn c94_l520_assert_invalid() { // Line 524 #[test] fn c95_l524_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, + 64, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1420,7 +1464,10 @@ fn c95_l524_assert_invalid() { // Line 528 #[test] fn c96_l528_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, + 64, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1428,7 +1475,10 @@ fn c96_l528_assert_invalid() { // Line 533 #[test] fn c97_l533_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 1, 4, 64, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 1, 4, 64, + 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1436,7 +1486,10 @@ fn c97_l533_assert_invalid() { // Line 539 #[test] fn c98_l539_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 1, 4, 64, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 1, 4, 64, + 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1444,7 +1497,10 @@ fn c98_l539_assert_invalid() { // Line 545 #[test] fn c99_l545_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 1, 4, 64, 5, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 1, 4, 64, + 5, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1452,7 +1508,10 @@ fn c99_l545_assert_invalid() { // Line 551 #[test] fn c100_l551_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, 4, 64, 65, 1, 5, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, 4, 64, + 65, 1, 5, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1460,7 +1519,10 @@ fn c100_l551_assert_invalid() { // Line 558 #[test] fn c101_l558_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 1, 4, 127, 5, 65, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 1, + 4, 127, 5, 65, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1468,7 +1530,10 @@ fn c101_l558_assert_invalid() { // Line 564 #[test] fn c102_l564_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 1, 4, 127, 65, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 1, 4, + 127, 65, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1476,7 +1541,10 @@ fn c102_l564_assert_invalid() { // Line 570 #[test] fn c103_l570_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 1, 4, 127, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 1, 4, + 127, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1484,7 +1552,10 @@ fn c103_l570_assert_invalid() { // Line 576 #[test] fn c104_l576_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 1, 4, 127, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 1, 4, + 127, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1492,7 +1563,10 @@ fn c104_l576_assert_invalid() { // Line 583 #[test] fn c105_l583_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 1, 4, 127, 1, 5, 65, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 1, + 4, 127, 1, 5, 65, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1500,7 +1574,10 @@ fn c105_l583_assert_invalid() { // Line 589 #[test] fn c106_l589_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 1, 4, 127, 65, 0, 5, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 1, + 4, 127, 65, 0, 5, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1508,7 +1585,10 @@ fn c106_l589_assert_invalid() { // Line 595 #[test] fn c107_l595_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 1, 4, 127, 1, 5, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 1, + 4, 127, 1, 5, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1516,7 +1596,10 @@ fn c107_l595_assert_invalid() { // Line 602 #[test] fn c108_l602_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, 4, 127, 66, 1, 5, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, + 4, 127, 66, 1, 5, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1524,7 +1607,10 @@ fn c108_l602_assert_invalid() { // Line 608 #[test] fn c109_l608_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, 4, 127, 65, 1, 5, 66, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, + 4, 127, 65, 1, 5, 66, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1532,7 +1618,10 @@ fn c109_l608_assert_invalid() { // Line 614 #[test] fn c110_l614_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, 4, 127, 66, 1, 5, 66, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, + 4, 127, 66, 1, 5, 66, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1540,7 +1629,10 @@ fn c110_l614_assert_invalid() { // Line 620 #[test] fn c111_l620_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 21, 1, 19, 0, 65, 1, 4, 127, 66, 1, 5, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 21, 1, 19, 0, 65, 1, + 4, 127, 66, 1, 5, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1548,7 +1640,10 @@ fn c111_l620_assert_invalid() { // Line 627 #[test] fn c112_l627_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, 4, 126, 0, 0, 0, 27, 5, 66, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, + 4, 126, 0, 0, 0, 27, 5, 66, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1556,7 +1651,10 @@ fn c112_l627_assert_invalid() { // Line 637 #[test] fn c113_l637_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 1, 4, 126, 66, 0, 5, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 1, + 4, 126, 66, 0, 5, 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1564,7 +1662,10 @@ fn c113_l637_assert_invalid() { // Line 647 #[test] fn c114_l647_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 65, 1, 4, 126, 0, 0, 0, 27, 5, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 65, 1, + 4, 126, 0, 0, 0, 27, 5, 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1572,7 +1673,10 @@ fn c114_l647_assert_invalid() { // Line 658 #[test] fn c115_l658_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, 4, 127, 12, 0, 5, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, + 4, 127, 12, 0, 5, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1580,7 +1684,10 @@ fn c115_l658_assert_invalid() { // Line 664 #[test] fn c116_l664_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, 4, 127, 65, 1, 5, 12, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, + 4, 127, 65, 1, 5, 12, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1588,7 +1695,10 @@ fn c116_l664_assert_invalid() { // Line 670 #[test] fn c117_l670_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 1, 4, 127, 12, 0, 65, 1, 5, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 1, + 4, 127, 12, 0, 65, 1, 5, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1596,7 +1706,10 @@ fn c117_l670_assert_invalid() { // Line 679 #[test] fn c118_l679_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 1, 4, 127, 65, 1, 5, 12, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 1, + 4, 127, 65, 1, 5, 12, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1604,7 +1717,10 @@ fn c118_l679_assert_invalid() { // Line 688 #[test] fn c119_l688_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 65, 1, 4, 127, 1, 12, 0, 65, 1, 5, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 65, 1, + 4, 127, 1, 12, 0, 65, 1, 5, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1612,7 +1728,10 @@ fn c119_l688_assert_invalid() { // Line 697 #[test] fn c120_l697_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 65, 1, 4, 127, 65, 1, 5, 1, 12, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 65, 1, + 4, 127, 65, 1, 5, 1, 12, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1620,7 +1739,10 @@ fn c120_l697_assert_invalid() { // Line 707 #[test] fn c121_l707_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 65, 1, 4, 127, 66, 1, 12, 0, 65, 1, 5, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 65, 1, + 4, 127, 66, 1, 12, 0, 65, 1, 5, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1628,7 +1750,10 @@ fn c121_l707_assert_invalid() { // Line 716 #[test] fn c122_l716_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 65, 1, 4, 127, 65, 1, 5, 66, 1, 12, 0, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 65, 1, + 4, 127, 65, 1, 5, 66, 1, 12, 0, 65, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1636,81 +1761,139 @@ fn c122_l716_assert_invalid() { // Line 727 #[test] fn c123_l727_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 110, 100, 32, 36, 108, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 110, 100, 32, 36, 108, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 731 #[test] fn c124_l731_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 110, 100, 32, 36, 108, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 110, 100, 32, 36, 108, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 735 #[test] fn c125_l735_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 108, 115, 101, 32, 36, 108, 32, 101, 110, 100, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 108, 115, 101, 32, 36, 108, 32, 101, 110, + 100, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 739 #[test] fn c126_l739_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 108, 115, 101, 32, 36, 108, 32, 101, 110, 100, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 108, 115, 101, 32, 36, 108, 32, + 101, 110, 100, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 743 #[test] fn c127_l743_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 108, 115, 101, 32, 101, 110, 100, 32, 36, 108, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 108, 115, 101, 32, 101, 110, 100, 32, 36, + 108, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 747 #[test] fn c128_l747_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 108, 115, 101, 32, 36, 108, 32, 101, 110, 100, 32, 36, 108, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 108, 115, 101, 32, 36, 108, 32, 101, 110, + 100, 32, 36, 108, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 751 #[test] fn c129_l751_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 108, 115, 101, 32, 36, 108, 49, 32, 101, 110, 100, 32, 36, 108, 50, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 108, 115, 101, 32, 36, 108, 49, 32, 101, 110, + 100, 32, 36, 108, 50, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 755 #[test] fn c130_l755_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 108, 115, 101, 32, 101, 110, 100, 32, 36, 108, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 108, 115, 101, 32, 101, 110, 100, + 32, 36, 108, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 759 #[test] fn c131_l759_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 108, 115, 101, 32, 36, 97, 32, 101, 110, 100, 32, 36, 108, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 108, 115, 101, 32, 36, 97, 32, + 101, 110, 100, 32, 36, 108, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 763 #[test] fn c132_l763_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 108, 115, 101, 32, 36, 108, 32, 101, 110, 100, 32, 36, 108, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 108, 115, 101, 32, 36, 108, 32, + 101, 110, 100, 32, 36, 108, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } #[test] diff --git a/lib/runtime/tests/spectests/int_exprs.rs b/lib/runtime/tests/spectests/int_exprs.rs index 4c294f2b4..e08d15e08 100644 --- a/lib/runtime/tests/spectests/int_exprs.rs +++ b/lib/runtime/tests/spectests/int_exprs.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 6 fn create_module_1() -> Box { @@ -61,8 +57,11 @@ fn create_module_1() -> Box { (export \"i64.no_fold_cmp_u_offset\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -73,7 +72,10 @@ fn start_module_1(instance: &mut Instance) { // Line 18 fn c1_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1_l18_action_invoke"); - let result = instance.call("i32.no_fold_cmp_s_offset", &[Value::I32(2147483647 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "i32.no_fold_cmp_s_offset", + &[Value::I32(2147483647 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -81,7 +83,10 @@ fn c1_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 19 fn c2_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2_l19_action_invoke"); - let result = instance.call("i32.no_fold_cmp_u_offset", &[Value::I32(-1 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "i32.no_fold_cmp_u_offset", + &[Value::I32(-1 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -89,7 +94,10 @@ fn c2_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 20 fn c3_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c3_l20_action_invoke"); - let result = instance.call("i64.no_fold_cmp_s_offset", &[Value::I64(9223372036854775807 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "i64.no_fold_cmp_s_offset", + &[Value::I64(9223372036854775807 as i64), Value::I64(0 as i64)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -97,7 +105,10 @@ fn c3_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 21 fn c4_l21_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c4_l21_action_invoke"); - let result = instance.call("i64.no_fold_cmp_u_offset", &[Value::I64(-1 as i64), Value::I64(0 as i64)]); + let result = instance.call( + "i64.no_fold_cmp_u_offset", + &[Value::I64(-1 as i64), Value::I64(0 as i64)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -124,8 +135,11 @@ fn create_module_2() -> Box { (export \"i64.no_fold_wrap_extend_s\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -136,7 +150,10 @@ fn start_module_2(instance: &mut Instance) { // Line 30 fn c6_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c6_l30_action_invoke"); - let result = instance.call("i64.no_fold_wrap_extend_s", &[Value::I64(4538991236898928 as i64)]); + let result = instance.call( + "i64.no_fold_wrap_extend_s", + &[Value::I64(4538991236898928 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(1079009392 as i64)))); result.map(|_| ()) } @@ -144,7 +161,10 @@ fn c6_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 31 fn c7_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c7_l31_action_invoke"); - let result = instance.call("i64.no_fold_wrap_extend_s", &[Value::I64(45230338458316960 as i64)]); + let result = instance.call( + "i64.no_fold_wrap_extend_s", + &[Value::I64(45230338458316960 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(-790564704 as i64)))); result.map(|_| ()) } @@ -169,8 +189,11 @@ fn create_module_3() -> Box { (export \"i64.no_fold_wrap_extend_u\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -181,7 +204,10 @@ fn start_module_3(instance: &mut Instance) { // Line 40 fn c9_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c9_l40_action_invoke"); - let result = instance.call("i64.no_fold_wrap_extend_u", &[Value::I64(4538991236898928 as i64)]); + let result = instance.call( + "i64.no_fold_wrap_extend_u", + &[Value::I64(4538991236898928 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(1079009392 as i64)))); result.map(|_| ()) } @@ -229,8 +255,11 @@ fn create_module_4() -> Box { (export \"i64.no_fold_shl_shr_u\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { @@ -257,7 +286,10 @@ fn c12_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 58 fn c13_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c13_l58_action_invoke"); - let result = instance.call("i64.no_fold_shl_shr_s", &[Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "i64.no_fold_shl_shr_s", + &[Value::I64(-9223372036854775808 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -265,7 +297,10 @@ fn c13_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 59 fn c14_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c14_l59_action_invoke"); - let result = instance.call("i64.no_fold_shl_shr_u", &[Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "i64.no_fold_shl_shr_u", + &[Value::I64(-9223372036854775808 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -316,8 +351,11 @@ fn create_module_5() -> Box { (export \"i64.no_fold_shr_u_shl\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_5(instance: &mut Instance) { @@ -403,8 +441,11 @@ fn create_module_6() -> Box { (export \"i64.no_fold_div_u_mul\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_6(instance: &mut Instance) { @@ -482,8 +523,11 @@ fn create_module_7() -> Box { (export \"i64.no_fold_div_u_self\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_7(instance: &mut Instance) { @@ -495,14 +539,14 @@ fn start_module_7(instance: &mut Instance) { fn c26_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c26_l113_action_invoke"); let result = instance.call("i32.no_fold_div_s_self", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c26_l113_assert_trap() { let mut instance = create_module_7(); - let result = c26_l113_action_invoke(&mut*instance); + let result = c26_l113_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -510,14 +554,14 @@ fn c26_l113_assert_trap() { fn c27_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c27_l114_action_invoke"); let result = instance.call("i32.no_fold_div_u_self", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c27_l114_assert_trap() { let mut instance = create_module_7(); - let result = c27_l114_action_invoke(&mut*instance); + let result = c27_l114_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -525,14 +569,14 @@ fn c27_l114_assert_trap() { fn c28_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c28_l115_action_invoke"); let result = instance.call("i64.no_fold_div_s_self", &[Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c28_l115_assert_trap() { let mut instance = create_module_7(); - let result = c28_l115_action_invoke(&mut*instance); + let result = c28_l115_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -540,14 +584,14 @@ fn c28_l115_assert_trap() { fn c29_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c29_l116_action_invoke"); let result = instance.call("i64.no_fold_div_u_self", &[Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c29_l116_assert_trap() { let mut instance = create_module_7(); - let result = c29_l116_action_invoke(&mut*instance); + let result = c29_l116_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -585,8 +629,11 @@ fn create_module_8() -> Box { (export \"i64.no_fold_rem_u_self\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_8(instance: &mut Instance) { @@ -598,14 +645,14 @@ fn start_module_8(instance: &mut Instance) { fn c31_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c31_l132_action_invoke"); let result = instance.call("i32.no_fold_rem_s_self", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c31_l132_assert_trap() { let mut instance = create_module_8(); - let result = c31_l132_action_invoke(&mut*instance); + let result = c31_l132_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -613,14 +660,14 @@ fn c31_l132_assert_trap() { fn c32_l133_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c32_l133_action_invoke"); let result = instance.call("i32.no_fold_rem_u_self", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c32_l133_assert_trap() { let mut instance = create_module_8(); - let result = c32_l133_action_invoke(&mut*instance); + let result = c32_l133_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -628,14 +675,14 @@ fn c32_l133_assert_trap() { fn c33_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c33_l134_action_invoke"); let result = instance.call("i64.no_fold_rem_s_self", &[Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c33_l134_assert_trap() { let mut instance = create_module_8(); - let result = c33_l134_action_invoke(&mut*instance); + let result = c33_l134_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -643,14 +690,14 @@ fn c33_l134_assert_trap() { fn c34_l135_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c34_l135_action_invoke"); let result = instance.call("i64.no_fold_rem_u_self", &[Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c34_l135_assert_trap() { let mut instance = create_module_8(); - let result = c34_l135_action_invoke(&mut*instance); + let result = c34_l135_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -696,8 +743,11 @@ fn create_module_9() -> Box { (export \"i64.no_fold_mul_div_u\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_9(instance: &mut Instance) { @@ -724,7 +774,10 @@ fn c37_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 153 fn c38_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c38_l153_action_invoke"); - let result = instance.call("i64.no_fold_mul_div_s", &[Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "i64.no_fold_mul_div_s", + &[Value::I64(-9223372036854775808 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -732,7 +785,10 @@ fn c38_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 154 fn c39_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c39_l154_action_invoke"); - let result = instance.call("i64.no_fold_mul_div_u", &[Value::I64(-9223372036854775808 as i64)]); + let result = instance.call( + "i64.no_fold_mul_div_u", + &[Value::I64(-9223372036854775808 as i64)], + ); assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); result.map(|_| ()) } @@ -765,8 +821,11 @@ fn create_module_10() -> Box { (export \"i64.no_fold_div_s_2\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_10(instance: &mut Instance) { @@ -816,8 +875,11 @@ fn create_module_11() -> Box { (export \"i64.no_fold_rem_s_2\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_11(instance: &mut Instance) { @@ -877,8 +939,11 @@ fn create_module_12() -> Box { (export \"i64.div_u_0\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_12(instance: &mut Instance) { @@ -890,14 +955,14 @@ fn start_module_12(instance: &mut Instance) { fn c47_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c47_l196_action_invoke"); let result = instance.call("i32.div_s_0", &[Value::I32(71 as i32)]); - + result.map(|_| ()) } #[test] fn c47_l196_assert_trap() { let mut instance = create_module_12(); - let result = c47_l196_action_invoke(&mut*instance); + let result = c47_l196_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -905,14 +970,14 @@ fn c47_l196_assert_trap() { fn c48_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c48_l197_action_invoke"); let result = instance.call("i32.div_u_0", &[Value::I32(71 as i32)]); - + result.map(|_| ()) } #[test] fn c48_l197_assert_trap() { let mut instance = create_module_12(); - let result = c48_l197_action_invoke(&mut*instance); + let result = c48_l197_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -920,14 +985,14 @@ fn c48_l197_assert_trap() { fn c49_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c49_l198_action_invoke"); let result = instance.call("i64.div_s_0", &[Value::I64(71 as i64)]); - + result.map(|_| ()) } #[test] fn c49_l198_assert_trap() { let mut instance = create_module_12(); - let result = c49_l198_action_invoke(&mut*instance); + let result = c49_l198_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -935,14 +1000,14 @@ fn c49_l198_assert_trap() { fn c50_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c50_l199_action_invoke"); let result = instance.call("i64.div_u_0", &[Value::I64(71 as i64)]); - + result.map(|_| ()) } #[test] fn c50_l199_assert_trap() { let mut instance = create_module_12(); - let result = c50_l199_action_invoke(&mut*instance); + let result = c50_l199_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -980,8 +1045,11 @@ fn create_module_13() -> Box { (export \"i64.div_u_3\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_13(instance: &mut Instance) { @@ -1095,8 +1163,11 @@ fn create_module_14() -> Box { (export \"i64.div_u_5\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_14(instance: &mut Instance) { @@ -1210,8 +1281,11 @@ fn create_module_15() -> Box { (export \"i64.div_u_7\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_15(instance: &mut Instance) { @@ -1325,8 +1399,11 @@ fn create_module_16() -> Box { (export \"i64.rem_u_3\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_16(instance: &mut Instance) { @@ -1440,8 +1517,11 @@ fn create_module_17() -> Box { (export \"i64.rem_u_5\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_17(instance: &mut Instance) { @@ -1555,8 +1635,11 @@ fn create_module_18() -> Box { (export \"i64.rem_u_7\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_18(instance: &mut Instance) { @@ -1660,8 +1743,11 @@ fn create_module_19() -> Box { (export \"i64.no_fold_div_neg1\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_19(instance: &mut Instance) { @@ -1673,29 +1759,32 @@ fn start_module_19(instance: &mut Instance) { fn c106_l349_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c106_l349_action_invoke"); let result = instance.call("i32.no_fold_div_neg1", &[Value::I32(-2147483648 as i32)]); - + result.map(|_| ()) } #[test] fn c106_l349_assert_trap() { let mut instance = create_module_19(); - let result = c106_l349_action_invoke(&mut*instance); + let result = c106_l349_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 350 fn c107_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c107_l350_action_invoke"); - let result = instance.call("i64.no_fold_div_neg1", &[Value::I64(-9223372036854775808 as i64)]); - + let result = instance.call( + "i64.no_fold_div_neg1", + &[Value::I64(-9223372036854775808 as i64)], + ); + result.map(|_| ()) } #[test] fn c107_l350_assert_trap() { let mut instance = create_module_19(); - let result = c107_l350_action_invoke(&mut*instance); + let result = c107_l350_action_invoke(&mut *instance); assert!(result.is_err()); } diff --git a/lib/runtime/tests/spectests/int_literals.rs b/lib/runtime/tests/spectests/int_literals.rs index 2507fb8e6..9e8f9cd0e 100644 --- a/lib/runtime/tests/spectests/int_literals.rs +++ b/lib/runtime/tests/spectests/int_literals.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { @@ -141,8 +137,11 @@ fn create_module_1() -> Box { (export \"i64-hex-sep2\" (func 29))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -393,161 +392,281 @@ fn c30_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 72 #[test] fn c31_l72_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 76 #[test] fn c32_l76_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 43, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 43, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 80 #[test] fn c33_l80_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 45, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 84 #[test] fn c34_l84_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 57, 57, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 57, 57, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 88 #[test] fn c35_l88_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 95, 95, 48, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 49, 95, 95, 48, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 92 #[test] fn c36_l92_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 95, 48, 120, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 95, 48, 120, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 96 #[test] fn c37_l96_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 95, 120, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 95, 120, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 100 #[test] fn c38_l100_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 104 #[test] fn c39_l104_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 48, 48, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 48, 48, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 108 #[test] fn c40_l108_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 102, 102, 95, 95, 102, 102, 102, 102, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 102, 102, 95, 95, 102, 102, 102, 102, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 113 #[test] fn c41_l113_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 117 #[test] fn c42_l117_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 43, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 43, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 121 #[test] fn c43_l121_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 45, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 125 #[test] fn c44_l125_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 57, 57, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 57, 57, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 129 #[test] fn c45_l129_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 95, 95, 48, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 49, 95, 95, 48, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 133 #[test] fn c46_l133_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 95, 48, 120, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 95, 48, 120, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 137 #[test] fn c47_l137_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 95, 120, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 95, 120, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 141 #[test] fn c48_l141_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 48, 48, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 95, 49, 48, 48, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 145 #[test] fn c49_l145_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 48, 48, 95, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 48, 48, 95, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 149 #[test] fn c50_l149_assert_malformed() { - let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 102, 102, 95, 95, 102, 102, 102, 102, 41, 41]; + let wasm_binary = [ + 40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, + 115, 116, 32, 48, 120, 102, 102, 95, 95, 102, 102, 102, 102, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } #[test] diff --git a/lib/runtime/tests/spectests/labels.rs b/lib/runtime/tests/spectests/labels.rs index 189cb7e62..b6cd3f613 100644 --- a/lib/runtime/tests/spectests/labels.rs +++ b/lib/runtime/tests/spectests/labels.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { @@ -457,8 +453,11 @@ fn create_module_1() -> Box { (export \"redefinition\" (func 17))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -669,7 +668,10 @@ fn c25_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 311 #[test] fn c26_l311_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 1, 13, 0, 140, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 1, + 13, 0, 140, 1, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -677,7 +679,10 @@ fn c26_l311_assert_invalid() { // Line 315 #[test] fn c27_l315_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 67, 0, 0, 0, 0, 65, 1, 13, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 67, 0, + 0, 0, 0, 65, 1, 13, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -685,7 +690,10 @@ fn c27_l315_assert_invalid() { // Line 319 #[test] fn c28_l319_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 67, 0, 0, 0, 0, 65, 1, 13, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 67, 0, + 0, 0, 0, 65, 1, 13, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/left_to_right.rs b/lib/runtime/tests/spectests/left_to_right.rs index 674c03b45..ad68122b6 100644 --- a/lib/runtime/tests/spectests/left_to_right.rs +++ b/lib/runtime/tests/spectests/left_to_right.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { @@ -965,8 +961,11 @@ fn create_module_1() -> Box { (elem (;0;) (i32.const 0) 0 1 2 3 4 5 6 7)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { diff --git a/lib/runtime/tests/spectests/loop_.rs b/lib/runtime/tests/spectests/loop_.rs index cf451a68a..8859be6c3 100644 --- a/lib/runtime/tests/spectests/loop_.rs +++ b/lib/runtime/tests/spectests/loop_.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -673,8 +669,11 @@ fn create_module_1() -> Box { (elem (;0;) (i32.const 0) 16)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -1213,7 +1212,10 @@ fn c66_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 386 #[test] fn c67_l386_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 64, 11, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1221,7 +1223,10 @@ fn c67_l386_assert_invalid() { // Line 390 #[test] fn c68_l390_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 64, 11, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1229,7 +1234,10 @@ fn c68_l390_assert_invalid() { // Line 394 #[test] fn c69_l394_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 64, 11, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1237,7 +1245,10 @@ fn c69_l394_assert_invalid() { // Line 398 #[test] fn c70_l398_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 64, 11, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1245,7 +1256,10 @@ fn c70_l398_assert_invalid() { // Line 403 #[test] fn c71_l403_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 3, 64, 65, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 3, 64, 65, 1, + 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1253,7 +1267,10 @@ fn c71_l403_assert_invalid() { // Line 409 #[test] fn c72_l409_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 127, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 127, + 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1261,7 +1278,10 @@ fn c72_l409_assert_invalid() { // Line 415 #[test] fn c73_l415_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 3, 127, 1, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 3, 127, 1, + 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1269,7 +1289,10 @@ fn c73_l415_assert_invalid() { // Line 421 #[test] fn c74_l421_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 3, 127, 67, 0, 0, 0, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 3, 127, + 67, 0, 0, 0, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1277,7 +1300,10 @@ fn c74_l421_assert_invalid() { // Line 427 #[test] fn c75_l427_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 3, 126, 0, 0, 0, 27, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 3, 126, + 0, 0, 0, 27, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1285,17 +1311,28 @@ fn c75_l427_assert_invalid() { // Line 435 #[test] fn c76_l435_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 108, 111, 111, 112, 32, 101, 110, 100, 32, 36, 108, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 108, 111, 111, 112, 32, 101, 110, 100, 32, 36, 108, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 439 #[test] fn c77_l439_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 108, 111, 111, 112, 32, 36, 97, 32, 101, 110, 100, 32, 36, 108, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 108, 111, 111, 112, 32, 36, 97, 32, 101, 110, 100, 32, 36, 108, + 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } #[test] diff --git a/lib/runtime/tests/spectests/memory.rs b/lib/runtime/tests/spectests/memory.rs index fd39b4068..6d82730ae 100644 --- a/lib/runtime/tests/spectests/memory.rs +++ b/lib/runtime/tests/spectests/memory.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 2 fn create_module_1() -> Box { @@ -24,8 +20,11 @@ fn create_module_1() -> Box { (memory (;0;) 0 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -46,8 +45,11 @@ fn create_module_2() -> Box { (memory (;0;) 0 1)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -68,8 +70,11 @@ fn create_module_3() -> Box { (memory (;0;) 1 256)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -90,8 +95,11 @@ fn create_module_4() -> Box { (memory (;0;) 0 65536)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { @@ -110,7 +118,10 @@ fn c4_l7_assert_invalid() { // Line 8 #[test] fn c5_l8_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 2, 20, 1, 8, 115, 112, 101, 99, 116, 101, 115, 116, 6, 109, 101, 109, 111, 114, 121, 2, 0, 0, 5, 3, 1, 0, 0]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 2, 20, 1, 8, 115, 112, 101, 99, 116, 101, 115, 116, 6, 109, + 101, 109, 111, 114, 121, 2, 0, 0, 5, 3, 1, 0, 0, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -133,8 +144,11 @@ fn create_module_5() -> Box { (data (;0;) (i32.const 0) \"\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_5(instance: &mut Instance) { @@ -169,8 +183,11 @@ fn create_module_6() -> Box { (data (;0;) (i32.const 0) \"\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_6(instance: &mut Instance) { @@ -205,8 +222,11 @@ fn create_module_7() -> Box { (data (;0;) (i32.const 0) \"x\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_7(instance: &mut Instance) { @@ -249,7 +269,10 @@ fn c14_l19_assert_invalid() { // Line 22 #[test] fn c15_l22_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 42, 2, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 42, 2, + 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -257,7 +280,10 @@ fn c15_l22_assert_invalid() { // Line 26 #[test] fn c16_l26_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 65, 0, 56, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 67, 0, 0, 0, + 0, 65, 0, 56, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -265,7 +291,10 @@ fn c16_l26_assert_invalid() { // Line 30 #[test] fn c17_l30_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 44, 0, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 44, 0, + 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -273,7 +302,10 @@ fn c17_l30_assert_invalid() { // Line 34 #[test] fn c18_l34_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 0, 65, 0, 58, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 0, 65, 0, + 58, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -281,7 +313,9 @@ fn c18_l34_assert_invalid() { // Line 38 #[test] fn c19_l38_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 63, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 63, 0, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -289,7 +323,10 @@ fn c19_l38_assert_invalid() { // Line 42 #[test] fn c20_l42_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 64, 0, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 64, 0, + 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -313,7 +350,9 @@ fn c22_l52_assert_invalid() { // Line 56 #[test] fn c23_l56_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 7, 1, 0, 128, 128, 128, 128, 8]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 7, 1, 0, 128, 128, 128, 128, 8, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -321,7 +360,9 @@ fn c23_l56_assert_invalid() { // Line 60 #[test] fn c24_l60_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 7, 1, 0, 255, 255, 255, 255, 15]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 7, 1, 0, 255, 255, 255, 255, 15, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -337,7 +378,9 @@ fn c25_l64_assert_invalid() { // Line 68 #[test] fn c26_l68_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 8, 1, 1, 0, 128, 128, 128, 128, 8]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 8, 1, 1, 0, 128, 128, 128, 128, 8, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -345,7 +388,9 @@ fn c26_l68_assert_invalid() { // Line 72 #[test] fn c27_l72_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 8, 1, 1, 0, 255, 255, 255, 255, 15]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 5, 8, 1, 1, 0, 255, 255, 255, 255, 15, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/memory_grow.rs b/lib/runtime/tests/spectests/memory_grow.rs index 99c725f29..43e112683 100644 --- a/lib/runtime/tests/spectests/memory_grow.rs +++ b/lib/runtime/tests/spectests/memory_grow.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { @@ -52,8 +48,11 @@ fn create_module_1() -> Box { (export \"size\" (func 5))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -73,14 +72,14 @@ fn c1_l14_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c2_l15_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2_l15_action_invoke"); let result = instance.call("store_at_zero", &[]); - + result.map(|_| ()) } #[test] fn c2_l15_assert_trap() { let mut instance = create_module_1(); - let result = c2_l15_action_invoke(&mut*instance); + let result = c2_l15_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -88,14 +87,14 @@ fn c2_l15_assert_trap() { fn c3_l16_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c3_l16_action_invoke"); let result = instance.call("load_at_zero", &[]); - + result.map(|_| ()) } #[test] fn c3_l16_assert_trap() { let mut instance = create_module_1(); - let result = c3_l16_action_invoke(&mut*instance); + let result = c3_l16_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -103,14 +102,14 @@ fn c3_l16_assert_trap() { fn c4_l17_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c4_l17_action_invoke"); let result = instance.call("store_at_page_size", &[]); - + result.map(|_| ()) } #[test] fn c4_l17_assert_trap() { let mut instance = create_module_1(); - let result = c4_l17_action_invoke(&mut*instance); + let result = c4_l17_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -118,14 +117,14 @@ fn c4_l17_assert_trap() { fn c5_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c5_l18_action_invoke"); let result = instance.call("load_at_page_size", &[]); - + result.map(|_| ()) } #[test] fn c5_l18_assert_trap() { let mut instance = create_module_1(); - let result = c5_l18_action_invoke(&mut*instance); + let result = c5_l18_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -173,14 +172,14 @@ fn c10_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c11_l24_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c11_l24_action_invoke"); let result = instance.call("store_at_page_size", &[]); - + result.map(|_| ()) } #[test] fn c11_l24_assert_trap() { let mut instance = create_module_1(); - let result = c11_l24_action_invoke(&mut*instance); + let result = c11_l24_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -188,14 +187,14 @@ fn c11_l24_assert_trap() { fn c12_l25_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c12_l25_action_invoke"); let result = instance.call("load_at_page_size", &[]); - + result.map(|_| ()) } #[test] fn c12_l25_assert_trap() { let mut instance = create_module_1(); - let result = c12_l25_action_invoke(&mut*instance); + let result = c12_l25_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -295,8 +294,11 @@ fn create_module_2() -> Box { (export \"grow\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -394,8 +396,11 @@ fn create_module_3() -> Box { (export \"grow\" (func 0))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -523,8 +528,11 @@ fn create_module_4() -> Box { (export \"check-memory-zero\" (func 1))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { @@ -535,7 +543,10 @@ fn start_module_4(instance: &mut Instance) { // Line 87 fn c40_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c40_l87_action_invoke"); - let result = instance.call("check-memory-zero", &[Value::I32(0 as i32), Value::I32(65535 as i32)]); + let result = instance.call( + "check-memory-zero", + &[Value::I32(0 as i32), Value::I32(65535 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -551,7 +562,10 @@ fn c41_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 89 fn c42_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c42_l89_action_invoke"); - let result = instance.call("check-memory-zero", &[Value::I32(65536 as i32), Value::I32(131071 as i32)]); + let result = instance.call( + "check-memory-zero", + &[Value::I32(65536 as i32), Value::I32(131071 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -567,7 +581,10 @@ fn c43_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 91 fn c44_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c44_l91_action_invoke"); - let result = instance.call("check-memory-zero", &[Value::I32(131072 as i32), Value::I32(196607 as i32)]); + let result = instance.call( + "check-memory-zero", + &[Value::I32(131072 as i32), Value::I32(196607 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -583,7 +600,10 @@ fn c45_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 93 fn c46_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c46_l93_action_invoke"); - let result = instance.call("check-memory-zero", &[Value::I32(196608 as i32), Value::I32(262143 as i32)]); + let result = instance.call( + "check-memory-zero", + &[Value::I32(196608 as i32), Value::I32(262143 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -599,7 +619,10 @@ fn c47_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 95 fn c48_l95_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c48_l95_action_invoke"); - let result = instance.call("check-memory-zero", &[Value::I32(262144 as i32), Value::I32(327679 as i32)]); + let result = instance.call( + "check-memory-zero", + &[Value::I32(262144 as i32), Value::I32(327679 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -615,7 +638,10 @@ fn c49_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 97 fn c50_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c50_l97_action_invoke"); - let result = instance.call("check-memory-zero", &[Value::I32(327680 as i32), Value::I32(393215 as i32)]); + let result = instance.call( + "check-memory-zero", + &[Value::I32(327680 as i32), Value::I32(393215 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); result.map(|_| ()) } @@ -909,8 +935,11 @@ fn create_module_5() -> Box { (elem (;0;) (i32.const 0) 14)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_5(instance: &mut Instance) { @@ -1009,7 +1038,10 @@ fn c62_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 275 fn c63_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c63_l275_action_invoke"); - let result = instance.call("as-select-first", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "as-select-first", + &[Value::I32(0 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1017,7 +1049,10 @@ fn c63_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 276 fn c64_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c64_l276_action_invoke"); - let result = instance.call("as-select-second", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "as-select-second", + &[Value::I32(0 as i32), Value::I32(0 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -1082,14 +1117,14 @@ fn c71_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c72_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c72_l286_action_invoke"); let result = instance.call("as-call_indirect-index", &[]); - + result.map(|_| ()) } #[test] fn c72_l286_assert_trap() { let mut instance = create_module_5(); - let result = c72_l286_action_invoke(&mut*instance); + let result = c72_l286_action_invoke(&mut *instance); assert!(result.is_err()); } diff --git a/lib/runtime/tests/spectests/memory_redundancy.rs b/lib/runtime/tests/spectests/memory_redundancy.rs index b4ca710a3..2d2f7458f 100644 --- a/lib/runtime/tests/spectests/memory_redundancy.rs +++ b/lib/runtime/tests/spectests/memory_redundancy.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 5 fn create_module_1() -> Box { @@ -100,8 +96,11 @@ fn create_module_1() -> Box { (export \"malloc_aliasing\" (func 5))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -121,7 +120,7 @@ fn c1_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c2_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2_l60_action_invoke"); let result = instance.call("zero_everything", &[]); - + result.map(|_| ()) } @@ -137,7 +136,7 @@ fn c3_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c4_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c4_l62_action_invoke"); let result = instance.call("zero_everything", &[]); - + result.map(|_| ()) } @@ -145,7 +144,12 @@ fn c4_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c5_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c5_l63_action_invoke"); let result = instance.call("test_dead_store", &[]); - assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000049f32))))); + assert_eq!( + result, + Ok(Some(Value::F32( + (0.000000000000000000000000000000000000000000049f32) + ))) + ); result.map(|_| ()) } @@ -153,7 +157,7 @@ fn c5_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c6_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c6_l64_action_invoke"); let result = instance.call("zero_everything", &[]); - + result.map(|_| ()) } diff --git a/lib/runtime/tests/spectests/memory_trap.rs b/lib/runtime/tests/spectests/memory_trap.rs index 4b515cbcd..997bdcbf3 100644 --- a/lib/runtime/tests/spectests/memory_trap.rs +++ b/lib/runtime/tests/spectests/memory_trap.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { @@ -48,8 +44,11 @@ fn create_module_1() -> Box { (export \"memory.grow\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -77,14 +76,14 @@ fn c2_l22_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c3_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c3_l23_action_invoke"); let result = instance.call("store", &[Value::I32(-3 as i32), Value::I32(13 as i32)]); - + result.map(|_| ()) } #[test] fn c3_l23_assert_trap() { let mut instance = create_module_1(); - let result = c3_l23_action_invoke(&mut*instance); + let result = c3_l23_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -92,14 +91,14 @@ fn c3_l23_assert_trap() { fn c4_l24_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c4_l24_action_invoke"); let result = instance.call("load", &[Value::I32(-3 as i32)]); - + result.map(|_| ()) } #[test] fn c4_l24_assert_trap() { let mut instance = create_module_1(); - let result = c4_l24_action_invoke(&mut*instance); + let result = c4_l24_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -107,14 +106,14 @@ fn c4_l24_assert_trap() { fn c5_l25_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c5_l25_action_invoke"); let result = instance.call("store", &[Value::I32(-2 as i32), Value::I32(13 as i32)]); - + result.map(|_| ()) } #[test] fn c5_l25_assert_trap() { let mut instance = create_module_1(); - let result = c5_l25_action_invoke(&mut*instance); + let result = c5_l25_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -122,14 +121,14 @@ fn c5_l25_assert_trap() { fn c6_l26_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c6_l26_action_invoke"); let result = instance.call("load", &[Value::I32(-2 as i32)]); - + result.map(|_| ()) } #[test] fn c6_l26_assert_trap() { let mut instance = create_module_1(); - let result = c6_l26_action_invoke(&mut*instance); + let result = c6_l26_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -137,14 +136,14 @@ fn c6_l26_assert_trap() { fn c7_l27_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c7_l27_action_invoke"); let result = instance.call("store", &[Value::I32(-1 as i32), Value::I32(13 as i32)]); - + result.map(|_| ()) } #[test] fn c7_l27_assert_trap() { let mut instance = create_module_1(); - let result = c7_l27_action_invoke(&mut*instance); + let result = c7_l27_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -152,14 +151,14 @@ fn c7_l27_assert_trap() { fn c8_l28_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c8_l28_action_invoke"); let result = instance.call("load", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c8_l28_assert_trap() { let mut instance = create_module_1(); - let result = c8_l28_action_invoke(&mut*instance); + let result = c8_l28_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -167,14 +166,14 @@ fn c8_l28_assert_trap() { fn c9_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c9_l29_action_invoke"); let result = instance.call("store", &[Value::I32(0 as i32), Value::I32(13 as i32)]); - + result.map(|_| ()) } #[test] fn c9_l29_assert_trap() { let mut instance = create_module_1(); - let result = c9_l29_action_invoke(&mut*instance); + let result = c9_l29_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -182,29 +181,32 @@ fn c9_l29_assert_trap() { fn c10_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c10_l30_action_invoke"); let result = instance.call("load", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c10_l30_assert_trap() { let mut instance = create_module_1(); - let result = c10_l30_action_invoke(&mut*instance); + let result = c10_l30_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 31 fn c11_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c11_l31_action_invoke"); - let result = instance.call("store", &[Value::I32(-2147483648 as i32), Value::I32(13 as i32)]); - + let result = instance.call( + "store", + &[Value::I32(-2147483648 as i32), Value::I32(13 as i32)], + ); + result.map(|_| ()) } #[test] fn c11_l31_assert_trap() { let mut instance = create_module_1(); - let result = c11_l31_action_invoke(&mut*instance); + let result = c11_l31_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -212,14 +214,14 @@ fn c11_l31_assert_trap() { fn c12_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c12_l32_action_invoke"); let result = instance.call("load", &[Value::I32(-2147483648 as i32)]); - + result.map(|_| ()) } #[test] fn c12_l32_assert_trap() { let mut instance = create_module_1(); - let result = c12_l32_action_invoke(&mut*instance); + let result = c12_l32_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -358,8 +360,11 @@ fn create_module_2() -> Box { (data (;1;) (i32.const 65528) \"abcdefgh\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -370,60 +375,72 @@ fn start_module_2(instance: &mut Instance) { // Line 111 fn c15_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c15_l111_action_invoke"); - let result = instance.call("i32.store", &[Value::I32(65536 as i32), Value::I32(0 as i32)]); - + let result = instance.call( + "i32.store", + &[Value::I32(65536 as i32), Value::I32(0 as i32)], + ); + result.map(|_| ()) } #[test] fn c15_l111_assert_trap() { let mut instance = create_module_2(); - let result = c15_l111_action_invoke(&mut*instance); + let result = c15_l111_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 112 fn c16_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c16_l112_action_invoke"); - let result = instance.call("i32.store", &[Value::I32(65535 as i32), Value::I32(0 as i32)]); - + let result = instance.call( + "i32.store", + &[Value::I32(65535 as i32), Value::I32(0 as i32)], + ); + result.map(|_| ()) } #[test] fn c16_l112_assert_trap() { let mut instance = create_module_2(); - let result = c16_l112_action_invoke(&mut*instance); + let result = c16_l112_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 113 fn c17_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c17_l113_action_invoke"); - let result = instance.call("i32.store", &[Value::I32(65534 as i32), Value::I32(0 as i32)]); - + let result = instance.call( + "i32.store", + &[Value::I32(65534 as i32), Value::I32(0 as i32)], + ); + result.map(|_| ()) } #[test] fn c17_l113_assert_trap() { let mut instance = create_module_2(); - let result = c17_l113_action_invoke(&mut*instance); + let result = c17_l113_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 114 fn c18_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c18_l114_action_invoke"); - let result = instance.call("i32.store", &[Value::I32(65533 as i32), Value::I32(0 as i32)]); - + let result = instance.call( + "i32.store", + &[Value::I32(65533 as i32), Value::I32(0 as i32)], + ); + result.map(|_| ()) } #[test] fn c18_l114_assert_trap() { let mut instance = create_module_2(); - let result = c18_l114_action_invoke(&mut*instance); + let result = c18_l114_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -431,14 +448,14 @@ fn c18_l114_assert_trap() { fn c19_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c19_l115_action_invoke"); let result = instance.call("i32.store", &[Value::I32(-1 as i32), Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c19_l115_assert_trap() { let mut instance = create_module_2(); - let result = c19_l115_action_invoke(&mut*instance); + let result = c19_l115_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -446,14 +463,14 @@ fn c19_l115_assert_trap() { fn c20_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c20_l116_action_invoke"); let result = instance.call("i32.store", &[Value::I32(-2 as i32), Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c20_l116_assert_trap() { let mut instance = create_module_2(); - let result = c20_l116_action_invoke(&mut*instance); + let result = c20_l116_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -461,14 +478,14 @@ fn c20_l116_assert_trap() { fn c21_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c21_l117_action_invoke"); let result = instance.call("i32.store", &[Value::I32(-3 as i32), Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c21_l117_assert_trap() { let mut instance = create_module_2(); - let result = c21_l117_action_invoke(&mut*instance); + let result = c21_l117_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -476,134 +493,158 @@ fn c21_l117_assert_trap() { fn c22_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c22_l118_action_invoke"); let result = instance.call("i32.store", &[Value::I32(-4 as i32), Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c22_l118_assert_trap() { let mut instance = create_module_2(); - let result = c22_l118_action_invoke(&mut*instance); + let result = c22_l118_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 119 fn c23_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c23_l119_action_invoke"); - let result = instance.call("i64.store", &[Value::I32(65536 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store", + &[Value::I32(65536 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c23_l119_assert_trap() { let mut instance = create_module_2(); - let result = c23_l119_action_invoke(&mut*instance); + let result = c23_l119_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 120 fn c24_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c24_l120_action_invoke"); - let result = instance.call("i64.store", &[Value::I32(65535 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store", + &[Value::I32(65535 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c24_l120_assert_trap() { let mut instance = create_module_2(); - let result = c24_l120_action_invoke(&mut*instance); + let result = c24_l120_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 121 fn c25_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c25_l121_action_invoke"); - let result = instance.call("i64.store", &[Value::I32(65534 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store", + &[Value::I32(65534 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c25_l121_assert_trap() { let mut instance = create_module_2(); - let result = c25_l121_action_invoke(&mut*instance); + let result = c25_l121_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 122 fn c26_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c26_l122_action_invoke"); - let result = instance.call("i64.store", &[Value::I32(65533 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store", + &[Value::I32(65533 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c26_l122_assert_trap() { let mut instance = create_module_2(); - let result = c26_l122_action_invoke(&mut*instance); + let result = c26_l122_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 123 fn c27_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c27_l123_action_invoke"); - let result = instance.call("i64.store", &[Value::I32(65532 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store", + &[Value::I32(65532 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c27_l123_assert_trap() { let mut instance = create_module_2(); - let result = c27_l123_action_invoke(&mut*instance); + let result = c27_l123_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 124 fn c28_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c28_l124_action_invoke"); - let result = instance.call("i64.store", &[Value::I32(65531 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store", + &[Value::I32(65531 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c28_l124_assert_trap() { let mut instance = create_module_2(); - let result = c28_l124_action_invoke(&mut*instance); + let result = c28_l124_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 125 fn c29_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c29_l125_action_invoke"); - let result = instance.call("i64.store", &[Value::I32(65530 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store", + &[Value::I32(65530 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c29_l125_assert_trap() { let mut instance = create_module_2(); - let result = c29_l125_action_invoke(&mut*instance); + let result = c29_l125_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 126 fn c30_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c30_l126_action_invoke"); - let result = instance.call("i64.store", &[Value::I32(65529 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store", + &[Value::I32(65529 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c30_l126_assert_trap() { let mut instance = create_module_2(); - let result = c30_l126_action_invoke(&mut*instance); + let result = c30_l126_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -611,14 +652,14 @@ fn c30_l126_assert_trap() { fn c31_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c31_l127_action_invoke"); let result = instance.call("i64.store", &[Value::I32(-1 as i32), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c31_l127_assert_trap() { let mut instance = create_module_2(); - let result = c31_l127_action_invoke(&mut*instance); + let result = c31_l127_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -626,14 +667,14 @@ fn c31_l127_assert_trap() { fn c32_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c32_l128_action_invoke"); let result = instance.call("i64.store", &[Value::I32(-2 as i32), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c32_l128_assert_trap() { let mut instance = create_module_2(); - let result = c32_l128_action_invoke(&mut*instance); + let result = c32_l128_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -641,14 +682,14 @@ fn c32_l128_assert_trap() { fn c33_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c33_l129_action_invoke"); let result = instance.call("i64.store", &[Value::I32(-3 as i32), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c33_l129_assert_trap() { let mut instance = create_module_2(); - let result = c33_l129_action_invoke(&mut*instance); + let result = c33_l129_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -656,14 +697,14 @@ fn c33_l129_assert_trap() { fn c34_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c34_l130_action_invoke"); let result = instance.call("i64.store", &[Value::I32(-4 as i32), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c34_l130_assert_trap() { let mut instance = create_module_2(); - let result = c34_l130_action_invoke(&mut*instance); + let result = c34_l130_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -671,14 +712,14 @@ fn c34_l130_assert_trap() { fn c35_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c35_l131_action_invoke"); let result = instance.call("i64.store", &[Value::I32(-5 as i32), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c35_l131_assert_trap() { let mut instance = create_module_2(); - let result = c35_l131_action_invoke(&mut*instance); + let result = c35_l131_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -686,14 +727,14 @@ fn c35_l131_assert_trap() { fn c36_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c36_l132_action_invoke"); let result = instance.call("i64.store", &[Value::I32(-6 as i32), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c36_l132_assert_trap() { let mut instance = create_module_2(); - let result = c36_l132_action_invoke(&mut*instance); + let result = c36_l132_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -701,14 +742,14 @@ fn c36_l132_assert_trap() { fn c37_l133_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c37_l133_action_invoke"); let result = instance.call("i64.store", &[Value::I32(-7 as i32), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c37_l133_assert_trap() { let mut instance = create_module_2(); - let result = c37_l133_action_invoke(&mut*instance); + let result = c37_l133_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -716,74 +757,86 @@ fn c37_l133_assert_trap() { fn c38_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c38_l134_action_invoke"); let result = instance.call("i64.store", &[Value::I32(-8 as i32), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c38_l134_assert_trap() { let mut instance = create_module_2(); - let result = c38_l134_action_invoke(&mut*instance); + let result = c38_l134_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 135 fn c39_l135_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c39_l135_action_invoke"); - let result = instance.call("f32.store", &[Value::I32(65536 as i32), Value::F32((0.0f32))]); - + let result = instance.call( + "f32.store", + &[Value::I32(65536 as i32), Value::F32((0.0f32))], + ); + result.map(|_| ()) } #[test] fn c39_l135_assert_trap() { let mut instance = create_module_2(); - let result = c39_l135_action_invoke(&mut*instance); + let result = c39_l135_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 136 fn c40_l136_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c40_l136_action_invoke"); - let result = instance.call("f32.store", &[Value::I32(65535 as i32), Value::F32((0.0f32))]); - + let result = instance.call( + "f32.store", + &[Value::I32(65535 as i32), Value::F32((0.0f32))], + ); + result.map(|_| ()) } #[test] fn c40_l136_assert_trap() { let mut instance = create_module_2(); - let result = c40_l136_action_invoke(&mut*instance); + let result = c40_l136_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 137 fn c41_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c41_l137_action_invoke"); - let result = instance.call("f32.store", &[Value::I32(65534 as i32), Value::F32((0.0f32))]); - + let result = instance.call( + "f32.store", + &[Value::I32(65534 as i32), Value::F32((0.0f32))], + ); + result.map(|_| ()) } #[test] fn c41_l137_assert_trap() { let mut instance = create_module_2(); - let result = c41_l137_action_invoke(&mut*instance); + let result = c41_l137_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 138 fn c42_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c42_l138_action_invoke"); - let result = instance.call("f32.store", &[Value::I32(65533 as i32), Value::F32((0.0f32))]); - + let result = instance.call( + "f32.store", + &[Value::I32(65533 as i32), Value::F32((0.0f32))], + ); + result.map(|_| ()) } #[test] fn c42_l138_assert_trap() { let mut instance = create_module_2(); - let result = c42_l138_action_invoke(&mut*instance); + let result = c42_l138_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -791,14 +844,14 @@ fn c42_l138_assert_trap() { fn c43_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c43_l139_action_invoke"); let result = instance.call("f32.store", &[Value::I32(-1 as i32), Value::F32((0.0f32))]); - + result.map(|_| ()) } #[test] fn c43_l139_assert_trap() { let mut instance = create_module_2(); - let result = c43_l139_action_invoke(&mut*instance); + let result = c43_l139_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -806,14 +859,14 @@ fn c43_l139_assert_trap() { fn c44_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c44_l140_action_invoke"); let result = instance.call("f32.store", &[Value::I32(-2 as i32), Value::F32((0.0f32))]); - + result.map(|_| ()) } #[test] fn c44_l140_assert_trap() { let mut instance = create_module_2(); - let result = c44_l140_action_invoke(&mut*instance); + let result = c44_l140_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -821,14 +874,14 @@ fn c44_l140_assert_trap() { fn c45_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c45_l141_action_invoke"); let result = instance.call("f32.store", &[Value::I32(-3 as i32), Value::F32((0.0f32))]); - + result.map(|_| ()) } #[test] fn c45_l141_assert_trap() { let mut instance = create_module_2(); - let result = c45_l141_action_invoke(&mut*instance); + let result = c45_l141_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -836,134 +889,158 @@ fn c45_l141_assert_trap() { fn c46_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c46_l142_action_invoke"); let result = instance.call("f32.store", &[Value::I32(-4 as i32), Value::F32((0.0f32))]); - + result.map(|_| ()) } #[test] fn c46_l142_assert_trap() { let mut instance = create_module_2(); - let result = c46_l142_action_invoke(&mut*instance); + let result = c46_l142_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 143 fn c47_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c47_l143_action_invoke"); - let result = instance.call("f64.store", &[Value::I32(65536 as i32), Value::F64((0.0f64))]); - + let result = instance.call( + "f64.store", + &[Value::I32(65536 as i32), Value::F64((0.0f64))], + ); + result.map(|_| ()) } #[test] fn c47_l143_assert_trap() { let mut instance = create_module_2(); - let result = c47_l143_action_invoke(&mut*instance); + let result = c47_l143_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 144 fn c48_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c48_l144_action_invoke"); - let result = instance.call("f64.store", &[Value::I32(65535 as i32), Value::F64((0.0f64))]); - + let result = instance.call( + "f64.store", + &[Value::I32(65535 as i32), Value::F64((0.0f64))], + ); + result.map(|_| ()) } #[test] fn c48_l144_assert_trap() { let mut instance = create_module_2(); - let result = c48_l144_action_invoke(&mut*instance); + let result = c48_l144_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 145 fn c49_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c49_l145_action_invoke"); - let result = instance.call("f64.store", &[Value::I32(65534 as i32), Value::F64((0.0f64))]); - + let result = instance.call( + "f64.store", + &[Value::I32(65534 as i32), Value::F64((0.0f64))], + ); + result.map(|_| ()) } #[test] fn c49_l145_assert_trap() { let mut instance = create_module_2(); - let result = c49_l145_action_invoke(&mut*instance); + let result = c49_l145_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 146 fn c50_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c50_l146_action_invoke"); - let result = instance.call("f64.store", &[Value::I32(65533 as i32), Value::F64((0.0f64))]); - + let result = instance.call( + "f64.store", + &[Value::I32(65533 as i32), Value::F64((0.0f64))], + ); + result.map(|_| ()) } #[test] fn c50_l146_assert_trap() { let mut instance = create_module_2(); - let result = c50_l146_action_invoke(&mut*instance); + let result = c50_l146_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 147 fn c51_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c51_l147_action_invoke"); - let result = instance.call("f64.store", &[Value::I32(65532 as i32), Value::F64((0.0f64))]); - + let result = instance.call( + "f64.store", + &[Value::I32(65532 as i32), Value::F64((0.0f64))], + ); + result.map(|_| ()) } #[test] fn c51_l147_assert_trap() { let mut instance = create_module_2(); - let result = c51_l147_action_invoke(&mut*instance); + let result = c51_l147_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 148 fn c52_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c52_l148_action_invoke"); - let result = instance.call("f64.store", &[Value::I32(65531 as i32), Value::F64((0.0f64))]); - + let result = instance.call( + "f64.store", + &[Value::I32(65531 as i32), Value::F64((0.0f64))], + ); + result.map(|_| ()) } #[test] fn c52_l148_assert_trap() { let mut instance = create_module_2(); - let result = c52_l148_action_invoke(&mut*instance); + let result = c52_l148_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 149 fn c53_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c53_l149_action_invoke"); - let result = instance.call("f64.store", &[Value::I32(65530 as i32), Value::F64((0.0f64))]); - + let result = instance.call( + "f64.store", + &[Value::I32(65530 as i32), Value::F64((0.0f64))], + ); + result.map(|_| ()) } #[test] fn c53_l149_assert_trap() { let mut instance = create_module_2(); - let result = c53_l149_action_invoke(&mut*instance); + let result = c53_l149_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 150 fn c54_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c54_l150_action_invoke"); - let result = instance.call("f64.store", &[Value::I32(65529 as i32), Value::F64((0.0f64))]); - + let result = instance.call( + "f64.store", + &[Value::I32(65529 as i32), Value::F64((0.0f64))], + ); + result.map(|_| ()) } #[test] fn c54_l150_assert_trap() { let mut instance = create_module_2(); - let result = c54_l150_action_invoke(&mut*instance); + let result = c54_l150_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -971,14 +1048,14 @@ fn c54_l150_assert_trap() { fn c55_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c55_l151_action_invoke"); let result = instance.call("f64.store", &[Value::I32(-1 as i32), Value::F64((0.0f64))]); - + result.map(|_| ()) } #[test] fn c55_l151_assert_trap() { let mut instance = create_module_2(); - let result = c55_l151_action_invoke(&mut*instance); + let result = c55_l151_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -986,14 +1063,14 @@ fn c55_l151_assert_trap() { fn c56_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c56_l152_action_invoke"); let result = instance.call("f64.store", &[Value::I32(-2 as i32), Value::F64((0.0f64))]); - + result.map(|_| ()) } #[test] fn c56_l152_assert_trap() { let mut instance = create_module_2(); - let result = c56_l152_action_invoke(&mut*instance); + let result = c56_l152_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1001,14 +1078,14 @@ fn c56_l152_assert_trap() { fn c57_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c57_l153_action_invoke"); let result = instance.call("f64.store", &[Value::I32(-3 as i32), Value::F64((0.0f64))]); - + result.map(|_| ()) } #[test] fn c57_l153_assert_trap() { let mut instance = create_module_2(); - let result = c57_l153_action_invoke(&mut*instance); + let result = c57_l153_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1016,14 +1093,14 @@ fn c57_l153_assert_trap() { fn c58_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c58_l154_action_invoke"); let result = instance.call("f64.store", &[Value::I32(-4 as i32), Value::F64((0.0f64))]); - + result.map(|_| ()) } #[test] fn c58_l154_assert_trap() { let mut instance = create_module_2(); - let result = c58_l154_action_invoke(&mut*instance); + let result = c58_l154_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1031,14 +1108,14 @@ fn c58_l154_assert_trap() { fn c59_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c59_l155_action_invoke"); let result = instance.call("f64.store", &[Value::I32(-5 as i32), Value::F64((0.0f64))]); - + result.map(|_| ()) } #[test] fn c59_l155_assert_trap() { let mut instance = create_module_2(); - let result = c59_l155_action_invoke(&mut*instance); + let result = c59_l155_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1046,14 +1123,14 @@ fn c59_l155_assert_trap() { fn c60_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c60_l156_action_invoke"); let result = instance.call("f64.store", &[Value::I32(-6 as i32), Value::F64((0.0f64))]); - + result.map(|_| ()) } #[test] fn c60_l156_assert_trap() { let mut instance = create_module_2(); - let result = c60_l156_action_invoke(&mut*instance); + let result = c60_l156_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1061,14 +1138,14 @@ fn c60_l156_assert_trap() { fn c61_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c61_l157_action_invoke"); let result = instance.call("f64.store", &[Value::I32(-7 as i32), Value::F64((0.0f64))]); - + result.map(|_| ()) } #[test] fn c61_l157_assert_trap() { let mut instance = create_module_2(); - let result = c61_l157_action_invoke(&mut*instance); + let result = c61_l157_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1076,29 +1153,32 @@ fn c61_l157_assert_trap() { fn c62_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c62_l158_action_invoke"); let result = instance.call("f64.store", &[Value::I32(-8 as i32), Value::F64((0.0f64))]); - + result.map(|_| ()) } #[test] fn c62_l158_assert_trap() { let mut instance = create_module_2(); - let result = c62_l158_action_invoke(&mut*instance); + let result = c62_l158_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 159 fn c63_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c63_l159_action_invoke"); - let result = instance.call("i32.store8", &[Value::I32(65536 as i32), Value::I32(0 as i32)]); - + let result = instance.call( + "i32.store8", + &[Value::I32(65536 as i32), Value::I32(0 as i32)], + ); + result.map(|_| ()) } #[test] fn c63_l159_assert_trap() { let mut instance = create_module_2(); - let result = c63_l159_action_invoke(&mut*instance); + let result = c63_l159_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1106,89 +1186,104 @@ fn c63_l159_assert_trap() { fn c64_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c64_l160_action_invoke"); let result = instance.call("i32.store8", &[Value::I32(-1 as i32), Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c64_l160_assert_trap() { let mut instance = create_module_2(); - let result = c64_l160_action_invoke(&mut*instance); + let result = c64_l160_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 161 fn c65_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c65_l161_action_invoke"); - let result = instance.call("i32.store16", &[Value::I32(65536 as i32), Value::I32(0 as i32)]); - + let result = instance.call( + "i32.store16", + &[Value::I32(65536 as i32), Value::I32(0 as i32)], + ); + result.map(|_| ()) } #[test] fn c65_l161_assert_trap() { let mut instance = create_module_2(); - let result = c65_l161_action_invoke(&mut*instance); + let result = c65_l161_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 162 fn c66_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c66_l162_action_invoke"); - let result = instance.call("i32.store16", &[Value::I32(65535 as i32), Value::I32(0 as i32)]); - + let result = instance.call( + "i32.store16", + &[Value::I32(65535 as i32), Value::I32(0 as i32)], + ); + result.map(|_| ()) } #[test] fn c66_l162_assert_trap() { let mut instance = create_module_2(); - let result = c66_l162_action_invoke(&mut*instance); + let result = c66_l162_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 163 fn c67_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c67_l163_action_invoke"); - let result = instance.call("i32.store16", &[Value::I32(-1 as i32), Value::I32(0 as i32)]); - + let result = instance.call( + "i32.store16", + &[Value::I32(-1 as i32), Value::I32(0 as i32)], + ); + result.map(|_| ()) } #[test] fn c67_l163_assert_trap() { let mut instance = create_module_2(); - let result = c67_l163_action_invoke(&mut*instance); + let result = c67_l163_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 164 fn c68_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c68_l164_action_invoke"); - let result = instance.call("i32.store16", &[Value::I32(-2 as i32), Value::I32(0 as i32)]); - + let result = instance.call( + "i32.store16", + &[Value::I32(-2 as i32), Value::I32(0 as i32)], + ); + result.map(|_| ()) } #[test] fn c68_l164_assert_trap() { let mut instance = create_module_2(); - let result = c68_l164_action_invoke(&mut*instance); + let result = c68_l164_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 165 fn c69_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c69_l165_action_invoke"); - let result = instance.call("i64.store8", &[Value::I32(65536 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store8", + &[Value::I32(65536 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c69_l165_assert_trap() { let mut instance = create_module_2(); - let result = c69_l165_action_invoke(&mut*instance); + let result = c69_l165_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1196,194 +1291,230 @@ fn c69_l165_assert_trap() { fn c70_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c70_l166_action_invoke"); let result = instance.call("i64.store8", &[Value::I32(-1 as i32), Value::I64(0 as i64)]); - + result.map(|_| ()) } #[test] fn c70_l166_assert_trap() { let mut instance = create_module_2(); - let result = c70_l166_action_invoke(&mut*instance); + let result = c70_l166_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 167 fn c71_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c71_l167_action_invoke"); - let result = instance.call("i64.store16", &[Value::I32(65536 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store16", + &[Value::I32(65536 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c71_l167_assert_trap() { let mut instance = create_module_2(); - let result = c71_l167_action_invoke(&mut*instance); + let result = c71_l167_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 168 fn c72_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c72_l168_action_invoke"); - let result = instance.call("i64.store16", &[Value::I32(65535 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store16", + &[Value::I32(65535 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c72_l168_assert_trap() { let mut instance = create_module_2(); - let result = c72_l168_action_invoke(&mut*instance); + let result = c72_l168_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 169 fn c73_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c73_l169_action_invoke"); - let result = instance.call("i64.store16", &[Value::I32(-1 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store16", + &[Value::I32(-1 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c73_l169_assert_trap() { let mut instance = create_module_2(); - let result = c73_l169_action_invoke(&mut*instance); + let result = c73_l169_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 170 fn c74_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c74_l170_action_invoke"); - let result = instance.call("i64.store16", &[Value::I32(-2 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store16", + &[Value::I32(-2 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c74_l170_assert_trap() { let mut instance = create_module_2(); - let result = c74_l170_action_invoke(&mut*instance); + let result = c74_l170_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 171 fn c75_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c75_l171_action_invoke"); - let result = instance.call("i64.store32", &[Value::I32(65536 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store32", + &[Value::I32(65536 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c75_l171_assert_trap() { let mut instance = create_module_2(); - let result = c75_l171_action_invoke(&mut*instance); + let result = c75_l171_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 172 fn c76_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c76_l172_action_invoke"); - let result = instance.call("i64.store32", &[Value::I32(65535 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store32", + &[Value::I32(65535 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c76_l172_assert_trap() { let mut instance = create_module_2(); - let result = c76_l172_action_invoke(&mut*instance); + let result = c76_l172_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 173 fn c77_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c77_l173_action_invoke"); - let result = instance.call("i64.store32", &[Value::I32(65534 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store32", + &[Value::I32(65534 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c77_l173_assert_trap() { let mut instance = create_module_2(); - let result = c77_l173_action_invoke(&mut*instance); + let result = c77_l173_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 174 fn c78_l174_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c78_l174_action_invoke"); - let result = instance.call("i64.store32", &[Value::I32(65533 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store32", + &[Value::I32(65533 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c78_l174_assert_trap() { let mut instance = create_module_2(); - let result = c78_l174_action_invoke(&mut*instance); + let result = c78_l174_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 175 fn c79_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c79_l175_action_invoke"); - let result = instance.call("i64.store32", &[Value::I32(-1 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store32", + &[Value::I32(-1 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c79_l175_assert_trap() { let mut instance = create_module_2(); - let result = c79_l175_action_invoke(&mut*instance); + let result = c79_l175_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 176 fn c80_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c80_l176_action_invoke"); - let result = instance.call("i64.store32", &[Value::I32(-2 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store32", + &[Value::I32(-2 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c80_l176_assert_trap() { let mut instance = create_module_2(); - let result = c80_l176_action_invoke(&mut*instance); + let result = c80_l176_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 177 fn c81_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c81_l177_action_invoke"); - let result = instance.call("i64.store32", &[Value::I32(-3 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store32", + &[Value::I32(-3 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c81_l177_assert_trap() { let mut instance = create_module_2(); - let result = c81_l177_action_invoke(&mut*instance); + let result = c81_l177_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 178 fn c82_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c82_l178_action_invoke"); - let result = instance.call("i64.store32", &[Value::I32(-4 as i32), Value::I64(0 as i64)]); - + let result = instance.call( + "i64.store32", + &[Value::I32(-4 as i32), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c82_l178_assert_trap() { let mut instance = create_module_2(); - let result = c82_l178_action_invoke(&mut*instance); + let result = c82_l178_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1391,14 +1522,14 @@ fn c82_l178_assert_trap() { fn c83_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c83_l179_action_invoke"); let result = instance.call("i32.load", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c83_l179_assert_trap() { let mut instance = create_module_2(); - let result = c83_l179_action_invoke(&mut*instance); + let result = c83_l179_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1406,14 +1537,14 @@ fn c83_l179_assert_trap() { fn c84_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c84_l180_action_invoke"); let result = instance.call("i32.load", &[Value::I32(65535 as i32)]); - + result.map(|_| ()) } #[test] fn c84_l180_assert_trap() { let mut instance = create_module_2(); - let result = c84_l180_action_invoke(&mut*instance); + let result = c84_l180_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1421,14 +1552,14 @@ fn c84_l180_assert_trap() { fn c85_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c85_l181_action_invoke"); let result = instance.call("i32.load", &[Value::I32(65534 as i32)]); - + result.map(|_| ()) } #[test] fn c85_l181_assert_trap() { let mut instance = create_module_2(); - let result = c85_l181_action_invoke(&mut*instance); + let result = c85_l181_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1436,14 +1567,14 @@ fn c85_l181_assert_trap() { fn c86_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c86_l182_action_invoke"); let result = instance.call("i32.load", &[Value::I32(65533 as i32)]); - + result.map(|_| ()) } #[test] fn c86_l182_assert_trap() { let mut instance = create_module_2(); - let result = c86_l182_action_invoke(&mut*instance); + let result = c86_l182_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1451,14 +1582,14 @@ fn c86_l182_assert_trap() { fn c87_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c87_l183_action_invoke"); let result = instance.call("i32.load", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c87_l183_assert_trap() { let mut instance = create_module_2(); - let result = c87_l183_action_invoke(&mut*instance); + let result = c87_l183_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1466,14 +1597,14 @@ fn c87_l183_assert_trap() { fn c88_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c88_l184_action_invoke"); let result = instance.call("i32.load", &[Value::I32(-2 as i32)]); - + result.map(|_| ()) } #[test] fn c88_l184_assert_trap() { let mut instance = create_module_2(); - let result = c88_l184_action_invoke(&mut*instance); + let result = c88_l184_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1481,14 +1612,14 @@ fn c88_l184_assert_trap() { fn c89_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c89_l185_action_invoke"); let result = instance.call("i32.load", &[Value::I32(-3 as i32)]); - + result.map(|_| ()) } #[test] fn c89_l185_assert_trap() { let mut instance = create_module_2(); - let result = c89_l185_action_invoke(&mut*instance); + let result = c89_l185_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1496,14 +1627,14 @@ fn c89_l185_assert_trap() { fn c90_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c90_l186_action_invoke"); let result = instance.call("i32.load", &[Value::I32(-4 as i32)]); - + result.map(|_| ()) } #[test] fn c90_l186_assert_trap() { let mut instance = create_module_2(); - let result = c90_l186_action_invoke(&mut*instance); + let result = c90_l186_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1511,14 +1642,14 @@ fn c90_l186_assert_trap() { fn c91_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c91_l187_action_invoke"); let result = instance.call("i64.load", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c91_l187_assert_trap() { let mut instance = create_module_2(); - let result = c91_l187_action_invoke(&mut*instance); + let result = c91_l187_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1526,14 +1657,14 @@ fn c91_l187_assert_trap() { fn c92_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c92_l188_action_invoke"); let result = instance.call("i64.load", &[Value::I32(65535 as i32)]); - + result.map(|_| ()) } #[test] fn c92_l188_assert_trap() { let mut instance = create_module_2(); - let result = c92_l188_action_invoke(&mut*instance); + let result = c92_l188_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1541,14 +1672,14 @@ fn c92_l188_assert_trap() { fn c93_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c93_l189_action_invoke"); let result = instance.call("i64.load", &[Value::I32(65534 as i32)]); - + result.map(|_| ()) } #[test] fn c93_l189_assert_trap() { let mut instance = create_module_2(); - let result = c93_l189_action_invoke(&mut*instance); + let result = c93_l189_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1556,14 +1687,14 @@ fn c93_l189_assert_trap() { fn c94_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c94_l190_action_invoke"); let result = instance.call("i64.load", &[Value::I32(65533 as i32)]); - + result.map(|_| ()) } #[test] fn c94_l190_assert_trap() { let mut instance = create_module_2(); - let result = c94_l190_action_invoke(&mut*instance); + let result = c94_l190_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1571,14 +1702,14 @@ fn c94_l190_assert_trap() { fn c95_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c95_l191_action_invoke"); let result = instance.call("i64.load", &[Value::I32(65532 as i32)]); - + result.map(|_| ()) } #[test] fn c95_l191_assert_trap() { let mut instance = create_module_2(); - let result = c95_l191_action_invoke(&mut*instance); + let result = c95_l191_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1586,14 +1717,14 @@ fn c95_l191_assert_trap() { fn c96_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c96_l192_action_invoke"); let result = instance.call("i64.load", &[Value::I32(65531 as i32)]); - + result.map(|_| ()) } #[test] fn c96_l192_assert_trap() { let mut instance = create_module_2(); - let result = c96_l192_action_invoke(&mut*instance); + let result = c96_l192_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1601,14 +1732,14 @@ fn c96_l192_assert_trap() { fn c97_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c97_l193_action_invoke"); let result = instance.call("i64.load", &[Value::I32(65530 as i32)]); - + result.map(|_| ()) } #[test] fn c97_l193_assert_trap() { let mut instance = create_module_2(); - let result = c97_l193_action_invoke(&mut*instance); + let result = c97_l193_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1616,14 +1747,14 @@ fn c97_l193_assert_trap() { fn c98_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c98_l194_action_invoke"); let result = instance.call("i64.load", &[Value::I32(65529 as i32)]); - + result.map(|_| ()) } #[test] fn c98_l194_assert_trap() { let mut instance = create_module_2(); - let result = c98_l194_action_invoke(&mut*instance); + let result = c98_l194_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1631,14 +1762,14 @@ fn c98_l194_assert_trap() { fn c99_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c99_l195_action_invoke"); let result = instance.call("i64.load", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c99_l195_assert_trap() { let mut instance = create_module_2(); - let result = c99_l195_action_invoke(&mut*instance); + let result = c99_l195_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1646,14 +1777,14 @@ fn c99_l195_assert_trap() { fn c100_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c100_l196_action_invoke"); let result = instance.call("i64.load", &[Value::I32(-2 as i32)]); - + result.map(|_| ()) } #[test] fn c100_l196_assert_trap() { let mut instance = create_module_2(); - let result = c100_l196_action_invoke(&mut*instance); + let result = c100_l196_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1661,14 +1792,14 @@ fn c100_l196_assert_trap() { fn c101_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c101_l197_action_invoke"); let result = instance.call("i64.load", &[Value::I32(-3 as i32)]); - + result.map(|_| ()) } #[test] fn c101_l197_assert_trap() { let mut instance = create_module_2(); - let result = c101_l197_action_invoke(&mut*instance); + let result = c101_l197_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1676,14 +1807,14 @@ fn c101_l197_assert_trap() { fn c102_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c102_l198_action_invoke"); let result = instance.call("i64.load", &[Value::I32(-4 as i32)]); - + result.map(|_| ()) } #[test] fn c102_l198_assert_trap() { let mut instance = create_module_2(); - let result = c102_l198_action_invoke(&mut*instance); + let result = c102_l198_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1691,14 +1822,14 @@ fn c102_l198_assert_trap() { fn c103_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c103_l199_action_invoke"); let result = instance.call("i64.load", &[Value::I32(-5 as i32)]); - + result.map(|_| ()) } #[test] fn c103_l199_assert_trap() { let mut instance = create_module_2(); - let result = c103_l199_action_invoke(&mut*instance); + let result = c103_l199_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1706,14 +1837,14 @@ fn c103_l199_assert_trap() { fn c104_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c104_l200_action_invoke"); let result = instance.call("i64.load", &[Value::I32(-6 as i32)]); - + result.map(|_| ()) } #[test] fn c104_l200_assert_trap() { let mut instance = create_module_2(); - let result = c104_l200_action_invoke(&mut*instance); + let result = c104_l200_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1721,14 +1852,14 @@ fn c104_l200_assert_trap() { fn c105_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c105_l201_action_invoke"); let result = instance.call("i64.load", &[Value::I32(-7 as i32)]); - + result.map(|_| ()) } #[test] fn c105_l201_assert_trap() { let mut instance = create_module_2(); - let result = c105_l201_action_invoke(&mut*instance); + let result = c105_l201_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1736,14 +1867,14 @@ fn c105_l201_assert_trap() { fn c106_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c106_l202_action_invoke"); let result = instance.call("i64.load", &[Value::I32(-8 as i32)]); - + result.map(|_| ()) } #[test] fn c106_l202_assert_trap() { let mut instance = create_module_2(); - let result = c106_l202_action_invoke(&mut*instance); + let result = c106_l202_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1751,14 +1882,14 @@ fn c106_l202_assert_trap() { fn c107_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c107_l203_action_invoke"); let result = instance.call("f32.load", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c107_l203_assert_trap() { let mut instance = create_module_2(); - let result = c107_l203_action_invoke(&mut*instance); + let result = c107_l203_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1766,14 +1897,14 @@ fn c107_l203_assert_trap() { fn c108_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c108_l204_action_invoke"); let result = instance.call("f32.load", &[Value::I32(65535 as i32)]); - + result.map(|_| ()) } #[test] fn c108_l204_assert_trap() { let mut instance = create_module_2(); - let result = c108_l204_action_invoke(&mut*instance); + let result = c108_l204_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1781,14 +1912,14 @@ fn c108_l204_assert_trap() { fn c109_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c109_l205_action_invoke"); let result = instance.call("f32.load", &[Value::I32(65534 as i32)]); - + result.map(|_| ()) } #[test] fn c109_l205_assert_trap() { let mut instance = create_module_2(); - let result = c109_l205_action_invoke(&mut*instance); + let result = c109_l205_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1796,14 +1927,14 @@ fn c109_l205_assert_trap() { fn c110_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c110_l206_action_invoke"); let result = instance.call("f32.load", &[Value::I32(65533 as i32)]); - + result.map(|_| ()) } #[test] fn c110_l206_assert_trap() { let mut instance = create_module_2(); - let result = c110_l206_action_invoke(&mut*instance); + let result = c110_l206_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1811,14 +1942,14 @@ fn c110_l206_assert_trap() { fn c111_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c111_l207_action_invoke"); let result = instance.call("f32.load", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c111_l207_assert_trap() { let mut instance = create_module_2(); - let result = c111_l207_action_invoke(&mut*instance); + let result = c111_l207_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1826,14 +1957,14 @@ fn c111_l207_assert_trap() { fn c112_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c112_l208_action_invoke"); let result = instance.call("f32.load", &[Value::I32(-2 as i32)]); - + result.map(|_| ()) } #[test] fn c112_l208_assert_trap() { let mut instance = create_module_2(); - let result = c112_l208_action_invoke(&mut*instance); + let result = c112_l208_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1841,14 +1972,14 @@ fn c112_l208_assert_trap() { fn c113_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c113_l209_action_invoke"); let result = instance.call("f32.load", &[Value::I32(-3 as i32)]); - + result.map(|_| ()) } #[test] fn c113_l209_assert_trap() { let mut instance = create_module_2(); - let result = c113_l209_action_invoke(&mut*instance); + let result = c113_l209_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1856,14 +1987,14 @@ fn c113_l209_assert_trap() { fn c114_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c114_l210_action_invoke"); let result = instance.call("f32.load", &[Value::I32(-4 as i32)]); - + result.map(|_| ()) } #[test] fn c114_l210_assert_trap() { let mut instance = create_module_2(); - let result = c114_l210_action_invoke(&mut*instance); + let result = c114_l210_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1871,14 +2002,14 @@ fn c114_l210_assert_trap() { fn c115_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c115_l211_action_invoke"); let result = instance.call("f64.load", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c115_l211_assert_trap() { let mut instance = create_module_2(); - let result = c115_l211_action_invoke(&mut*instance); + let result = c115_l211_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1886,14 +2017,14 @@ fn c115_l211_assert_trap() { fn c116_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c116_l212_action_invoke"); let result = instance.call("f64.load", &[Value::I32(65535 as i32)]); - + result.map(|_| ()) } #[test] fn c116_l212_assert_trap() { let mut instance = create_module_2(); - let result = c116_l212_action_invoke(&mut*instance); + let result = c116_l212_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1901,14 +2032,14 @@ fn c116_l212_assert_trap() { fn c117_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c117_l213_action_invoke"); let result = instance.call("f64.load", &[Value::I32(65534 as i32)]); - + result.map(|_| ()) } #[test] fn c117_l213_assert_trap() { let mut instance = create_module_2(); - let result = c117_l213_action_invoke(&mut*instance); + let result = c117_l213_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1916,14 +2047,14 @@ fn c117_l213_assert_trap() { fn c118_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c118_l214_action_invoke"); let result = instance.call("f64.load", &[Value::I32(65533 as i32)]); - + result.map(|_| ()) } #[test] fn c118_l214_assert_trap() { let mut instance = create_module_2(); - let result = c118_l214_action_invoke(&mut*instance); + let result = c118_l214_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1931,14 +2062,14 @@ fn c118_l214_assert_trap() { fn c119_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c119_l215_action_invoke"); let result = instance.call("f64.load", &[Value::I32(65532 as i32)]); - + result.map(|_| ()) } #[test] fn c119_l215_assert_trap() { let mut instance = create_module_2(); - let result = c119_l215_action_invoke(&mut*instance); + let result = c119_l215_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1946,14 +2077,14 @@ fn c119_l215_assert_trap() { fn c120_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c120_l216_action_invoke"); let result = instance.call("f64.load", &[Value::I32(65531 as i32)]); - + result.map(|_| ()) } #[test] fn c120_l216_assert_trap() { let mut instance = create_module_2(); - let result = c120_l216_action_invoke(&mut*instance); + let result = c120_l216_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1961,14 +2092,14 @@ fn c120_l216_assert_trap() { fn c121_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c121_l217_action_invoke"); let result = instance.call("f64.load", &[Value::I32(65530 as i32)]); - + result.map(|_| ()) } #[test] fn c121_l217_assert_trap() { let mut instance = create_module_2(); - let result = c121_l217_action_invoke(&mut*instance); + let result = c121_l217_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1976,14 +2107,14 @@ fn c121_l217_assert_trap() { fn c122_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c122_l218_action_invoke"); let result = instance.call("f64.load", &[Value::I32(65529 as i32)]); - + result.map(|_| ()) } #[test] fn c122_l218_assert_trap() { let mut instance = create_module_2(); - let result = c122_l218_action_invoke(&mut*instance); + let result = c122_l218_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -1991,14 +2122,14 @@ fn c122_l218_assert_trap() { fn c123_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c123_l219_action_invoke"); let result = instance.call("f64.load", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c123_l219_assert_trap() { let mut instance = create_module_2(); - let result = c123_l219_action_invoke(&mut*instance); + let result = c123_l219_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2006,14 +2137,14 @@ fn c123_l219_assert_trap() { fn c124_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c124_l220_action_invoke"); let result = instance.call("f64.load", &[Value::I32(-2 as i32)]); - + result.map(|_| ()) } #[test] fn c124_l220_assert_trap() { let mut instance = create_module_2(); - let result = c124_l220_action_invoke(&mut*instance); + let result = c124_l220_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2021,14 +2152,14 @@ fn c124_l220_assert_trap() { fn c125_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c125_l221_action_invoke"); let result = instance.call("f64.load", &[Value::I32(-3 as i32)]); - + result.map(|_| ()) } #[test] fn c125_l221_assert_trap() { let mut instance = create_module_2(); - let result = c125_l221_action_invoke(&mut*instance); + let result = c125_l221_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2036,14 +2167,14 @@ fn c125_l221_assert_trap() { fn c126_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c126_l222_action_invoke"); let result = instance.call("f64.load", &[Value::I32(-4 as i32)]); - + result.map(|_| ()) } #[test] fn c126_l222_assert_trap() { let mut instance = create_module_2(); - let result = c126_l222_action_invoke(&mut*instance); + let result = c126_l222_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2051,14 +2182,14 @@ fn c126_l222_assert_trap() { fn c127_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c127_l223_action_invoke"); let result = instance.call("f64.load", &[Value::I32(-5 as i32)]); - + result.map(|_| ()) } #[test] fn c127_l223_assert_trap() { let mut instance = create_module_2(); - let result = c127_l223_action_invoke(&mut*instance); + let result = c127_l223_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2066,14 +2197,14 @@ fn c127_l223_assert_trap() { fn c128_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c128_l224_action_invoke"); let result = instance.call("f64.load", &[Value::I32(-6 as i32)]); - + result.map(|_| ()) } #[test] fn c128_l224_assert_trap() { let mut instance = create_module_2(); - let result = c128_l224_action_invoke(&mut*instance); + let result = c128_l224_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2081,14 +2212,14 @@ fn c128_l224_assert_trap() { fn c129_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c129_l225_action_invoke"); let result = instance.call("f64.load", &[Value::I32(-7 as i32)]); - + result.map(|_| ()) } #[test] fn c129_l225_assert_trap() { let mut instance = create_module_2(); - let result = c129_l225_action_invoke(&mut*instance); + let result = c129_l225_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2096,14 +2227,14 @@ fn c129_l225_assert_trap() { fn c130_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c130_l226_action_invoke"); let result = instance.call("f64.load", &[Value::I32(-8 as i32)]); - + result.map(|_| ()) } #[test] fn c130_l226_assert_trap() { let mut instance = create_module_2(); - let result = c130_l226_action_invoke(&mut*instance); + let result = c130_l226_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2111,14 +2242,14 @@ fn c130_l226_assert_trap() { fn c131_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c131_l227_action_invoke"); let result = instance.call("i32.load8_s", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c131_l227_assert_trap() { let mut instance = create_module_2(); - let result = c131_l227_action_invoke(&mut*instance); + let result = c131_l227_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2126,14 +2257,14 @@ fn c131_l227_assert_trap() { fn c132_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c132_l228_action_invoke"); let result = instance.call("i32.load8_s", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c132_l228_assert_trap() { let mut instance = create_module_2(); - let result = c132_l228_action_invoke(&mut*instance); + let result = c132_l228_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2141,14 +2272,14 @@ fn c132_l228_assert_trap() { fn c133_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c133_l229_action_invoke"); let result = instance.call("i32.load8_u", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c133_l229_assert_trap() { let mut instance = create_module_2(); - let result = c133_l229_action_invoke(&mut*instance); + let result = c133_l229_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2156,14 +2287,14 @@ fn c133_l229_assert_trap() { fn c134_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c134_l230_action_invoke"); let result = instance.call("i32.load8_u", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c134_l230_assert_trap() { let mut instance = create_module_2(); - let result = c134_l230_action_invoke(&mut*instance); + let result = c134_l230_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2171,14 +2302,14 @@ fn c134_l230_assert_trap() { fn c135_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c135_l231_action_invoke"); let result = instance.call("i32.load16_s", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c135_l231_assert_trap() { let mut instance = create_module_2(); - let result = c135_l231_action_invoke(&mut*instance); + let result = c135_l231_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2186,14 +2317,14 @@ fn c135_l231_assert_trap() { fn c136_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c136_l232_action_invoke"); let result = instance.call("i32.load16_s", &[Value::I32(65535 as i32)]); - + result.map(|_| ()) } #[test] fn c136_l232_assert_trap() { let mut instance = create_module_2(); - let result = c136_l232_action_invoke(&mut*instance); + let result = c136_l232_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2201,14 +2332,14 @@ fn c136_l232_assert_trap() { fn c137_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c137_l233_action_invoke"); let result = instance.call("i32.load16_s", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c137_l233_assert_trap() { let mut instance = create_module_2(); - let result = c137_l233_action_invoke(&mut*instance); + let result = c137_l233_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2216,14 +2347,14 @@ fn c137_l233_assert_trap() { fn c138_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c138_l234_action_invoke"); let result = instance.call("i32.load16_s", &[Value::I32(-2 as i32)]); - + result.map(|_| ()) } #[test] fn c138_l234_assert_trap() { let mut instance = create_module_2(); - let result = c138_l234_action_invoke(&mut*instance); + let result = c138_l234_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2231,14 +2362,14 @@ fn c138_l234_assert_trap() { fn c139_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c139_l235_action_invoke"); let result = instance.call("i32.load16_u", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c139_l235_assert_trap() { let mut instance = create_module_2(); - let result = c139_l235_action_invoke(&mut*instance); + let result = c139_l235_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2246,14 +2377,14 @@ fn c139_l235_assert_trap() { fn c140_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c140_l236_action_invoke"); let result = instance.call("i32.load16_u", &[Value::I32(65535 as i32)]); - + result.map(|_| ()) } #[test] fn c140_l236_assert_trap() { let mut instance = create_module_2(); - let result = c140_l236_action_invoke(&mut*instance); + let result = c140_l236_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2261,14 +2392,14 @@ fn c140_l236_assert_trap() { fn c141_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c141_l237_action_invoke"); let result = instance.call("i32.load16_u", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c141_l237_assert_trap() { let mut instance = create_module_2(); - let result = c141_l237_action_invoke(&mut*instance); + let result = c141_l237_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2276,14 +2407,14 @@ fn c141_l237_assert_trap() { fn c142_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c142_l238_action_invoke"); let result = instance.call("i32.load16_u", &[Value::I32(-2 as i32)]); - + result.map(|_| ()) } #[test] fn c142_l238_assert_trap() { let mut instance = create_module_2(); - let result = c142_l238_action_invoke(&mut*instance); + let result = c142_l238_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2291,14 +2422,14 @@ fn c142_l238_assert_trap() { fn c143_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c143_l239_action_invoke"); let result = instance.call("i64.load8_s", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c143_l239_assert_trap() { let mut instance = create_module_2(); - let result = c143_l239_action_invoke(&mut*instance); + let result = c143_l239_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2306,14 +2437,14 @@ fn c143_l239_assert_trap() { fn c144_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c144_l240_action_invoke"); let result = instance.call("i64.load8_s", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c144_l240_assert_trap() { let mut instance = create_module_2(); - let result = c144_l240_action_invoke(&mut*instance); + let result = c144_l240_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2321,14 +2452,14 @@ fn c144_l240_assert_trap() { fn c145_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c145_l241_action_invoke"); let result = instance.call("i64.load8_u", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c145_l241_assert_trap() { let mut instance = create_module_2(); - let result = c145_l241_action_invoke(&mut*instance); + let result = c145_l241_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2336,14 +2467,14 @@ fn c145_l241_assert_trap() { fn c146_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c146_l242_action_invoke"); let result = instance.call("i64.load8_u", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c146_l242_assert_trap() { let mut instance = create_module_2(); - let result = c146_l242_action_invoke(&mut*instance); + let result = c146_l242_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2351,14 +2482,14 @@ fn c146_l242_assert_trap() { fn c147_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c147_l243_action_invoke"); let result = instance.call("i64.load16_s", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c147_l243_assert_trap() { let mut instance = create_module_2(); - let result = c147_l243_action_invoke(&mut*instance); + let result = c147_l243_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2366,14 +2497,14 @@ fn c147_l243_assert_trap() { fn c148_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c148_l244_action_invoke"); let result = instance.call("i64.load16_s", &[Value::I32(65535 as i32)]); - + result.map(|_| ()) } #[test] fn c148_l244_assert_trap() { let mut instance = create_module_2(); - let result = c148_l244_action_invoke(&mut*instance); + let result = c148_l244_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2381,14 +2512,14 @@ fn c148_l244_assert_trap() { fn c149_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c149_l245_action_invoke"); let result = instance.call("i64.load16_s", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c149_l245_assert_trap() { let mut instance = create_module_2(); - let result = c149_l245_action_invoke(&mut*instance); + let result = c149_l245_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2396,14 +2527,14 @@ fn c149_l245_assert_trap() { fn c150_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c150_l246_action_invoke"); let result = instance.call("i64.load16_s", &[Value::I32(-2 as i32)]); - + result.map(|_| ()) } #[test] fn c150_l246_assert_trap() { let mut instance = create_module_2(); - let result = c150_l246_action_invoke(&mut*instance); + let result = c150_l246_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2411,14 +2542,14 @@ fn c150_l246_assert_trap() { fn c151_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c151_l247_action_invoke"); let result = instance.call("i64.load16_u", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c151_l247_assert_trap() { let mut instance = create_module_2(); - let result = c151_l247_action_invoke(&mut*instance); + let result = c151_l247_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2426,14 +2557,14 @@ fn c151_l247_assert_trap() { fn c152_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c152_l248_action_invoke"); let result = instance.call("i64.load16_u", &[Value::I32(65535 as i32)]); - + result.map(|_| ()) } #[test] fn c152_l248_assert_trap() { let mut instance = create_module_2(); - let result = c152_l248_action_invoke(&mut*instance); + let result = c152_l248_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2441,14 +2572,14 @@ fn c152_l248_assert_trap() { fn c153_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c153_l249_action_invoke"); let result = instance.call("i64.load16_u", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c153_l249_assert_trap() { let mut instance = create_module_2(); - let result = c153_l249_action_invoke(&mut*instance); + let result = c153_l249_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2456,14 +2587,14 @@ fn c153_l249_assert_trap() { fn c154_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c154_l250_action_invoke"); let result = instance.call("i64.load16_u", &[Value::I32(-2 as i32)]); - + result.map(|_| ()) } #[test] fn c154_l250_assert_trap() { let mut instance = create_module_2(); - let result = c154_l250_action_invoke(&mut*instance); + let result = c154_l250_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2471,14 +2602,14 @@ fn c154_l250_assert_trap() { fn c155_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c155_l251_action_invoke"); let result = instance.call("i64.load32_s", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c155_l251_assert_trap() { let mut instance = create_module_2(); - let result = c155_l251_action_invoke(&mut*instance); + let result = c155_l251_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2486,14 +2617,14 @@ fn c155_l251_assert_trap() { fn c156_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c156_l252_action_invoke"); let result = instance.call("i64.load32_s", &[Value::I32(65535 as i32)]); - + result.map(|_| ()) } #[test] fn c156_l252_assert_trap() { let mut instance = create_module_2(); - let result = c156_l252_action_invoke(&mut*instance); + let result = c156_l252_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2501,14 +2632,14 @@ fn c156_l252_assert_trap() { fn c157_l253_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c157_l253_action_invoke"); let result = instance.call("i64.load32_s", &[Value::I32(65534 as i32)]); - + result.map(|_| ()) } #[test] fn c157_l253_assert_trap() { let mut instance = create_module_2(); - let result = c157_l253_action_invoke(&mut*instance); + let result = c157_l253_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2516,14 +2647,14 @@ fn c157_l253_assert_trap() { fn c158_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c158_l254_action_invoke"); let result = instance.call("i64.load32_s", &[Value::I32(65533 as i32)]); - + result.map(|_| ()) } #[test] fn c158_l254_assert_trap() { let mut instance = create_module_2(); - let result = c158_l254_action_invoke(&mut*instance); + let result = c158_l254_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2531,14 +2662,14 @@ fn c158_l254_assert_trap() { fn c159_l255_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c159_l255_action_invoke"); let result = instance.call("i64.load32_s", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c159_l255_assert_trap() { let mut instance = create_module_2(); - let result = c159_l255_action_invoke(&mut*instance); + let result = c159_l255_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2546,14 +2677,14 @@ fn c159_l255_assert_trap() { fn c160_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c160_l256_action_invoke"); let result = instance.call("i64.load32_s", &[Value::I32(-2 as i32)]); - + result.map(|_| ()) } #[test] fn c160_l256_assert_trap() { let mut instance = create_module_2(); - let result = c160_l256_action_invoke(&mut*instance); + let result = c160_l256_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2561,14 +2692,14 @@ fn c160_l256_assert_trap() { fn c161_l257_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c161_l257_action_invoke"); let result = instance.call("i64.load32_s", &[Value::I32(-3 as i32)]); - + result.map(|_| ()) } #[test] fn c161_l257_assert_trap() { let mut instance = create_module_2(); - let result = c161_l257_action_invoke(&mut*instance); + let result = c161_l257_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2576,14 +2707,14 @@ fn c161_l257_assert_trap() { fn c162_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c162_l258_action_invoke"); let result = instance.call("i64.load32_s", &[Value::I32(-4 as i32)]); - + result.map(|_| ()) } #[test] fn c162_l258_assert_trap() { let mut instance = create_module_2(); - let result = c162_l258_action_invoke(&mut*instance); + let result = c162_l258_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2591,14 +2722,14 @@ fn c162_l258_assert_trap() { fn c163_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c163_l259_action_invoke"); let result = instance.call("i64.load32_u", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c163_l259_assert_trap() { let mut instance = create_module_2(); - let result = c163_l259_action_invoke(&mut*instance); + let result = c163_l259_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2606,14 +2737,14 @@ fn c163_l259_assert_trap() { fn c164_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c164_l260_action_invoke"); let result = instance.call("i64.load32_u", &[Value::I32(65535 as i32)]); - + result.map(|_| ()) } #[test] fn c164_l260_assert_trap() { let mut instance = create_module_2(); - let result = c164_l260_action_invoke(&mut*instance); + let result = c164_l260_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2621,14 +2752,14 @@ fn c164_l260_assert_trap() { fn c165_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c165_l261_action_invoke"); let result = instance.call("i64.load32_u", &[Value::I32(65534 as i32)]); - + result.map(|_| ()) } #[test] fn c165_l261_assert_trap() { let mut instance = create_module_2(); - let result = c165_l261_action_invoke(&mut*instance); + let result = c165_l261_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2636,14 +2767,14 @@ fn c165_l261_assert_trap() { fn c166_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c166_l262_action_invoke"); let result = instance.call("i64.load32_u", &[Value::I32(65533 as i32)]); - + result.map(|_| ()) } #[test] fn c166_l262_assert_trap() { let mut instance = create_module_2(); - let result = c166_l262_action_invoke(&mut*instance); + let result = c166_l262_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2651,14 +2782,14 @@ fn c166_l262_assert_trap() { fn c167_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c167_l263_action_invoke"); let result = instance.call("i64.load32_u", &[Value::I32(-1 as i32)]); - + result.map(|_| ()) } #[test] fn c167_l263_assert_trap() { let mut instance = create_module_2(); - let result = c167_l263_action_invoke(&mut*instance); + let result = c167_l263_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2666,14 +2797,14 @@ fn c167_l263_assert_trap() { fn c168_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c168_l264_action_invoke"); let result = instance.call("i64.load32_u", &[Value::I32(-2 as i32)]); - + result.map(|_| ()) } #[test] fn c168_l264_assert_trap() { let mut instance = create_module_2(); - let result = c168_l264_action_invoke(&mut*instance); + let result = c168_l264_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2681,14 +2812,14 @@ fn c168_l264_assert_trap() { fn c169_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c169_l265_action_invoke"); let result = instance.call("i64.load32_u", &[Value::I32(-3 as i32)]); - + result.map(|_| ()) } #[test] fn c169_l265_assert_trap() { let mut instance = create_module_2(); - let result = c169_l265_action_invoke(&mut*instance); + let result = c169_l265_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -2696,14 +2827,14 @@ fn c169_l265_assert_trap() { fn c170_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c170_l266_action_invoke"); let result = instance.call("i64.load32_u", &[Value::I32(-4 as i32)]); - + result.map(|_| ()) } #[test] fn c170_l266_assert_trap() { let mut instance = create_module_2(); - let result = c170_l266_action_invoke(&mut*instance); + let result = c170_l266_action_invoke(&mut *instance); assert!(result.is_err()); } diff --git a/lib/runtime/tests/spectests/nop.rs b/lib/runtime/tests/spectests/nop.rs index a2cf1c63b..61c00bf80 100644 --- a/lib/runtime/tests/spectests/nop.rs +++ b/lib/runtime/tests/spectests/nop.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -638,8 +634,11 @@ fn create_module_1() -> Box { (elem (;0;) (i32.const 0) 61)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -970,7 +969,14 @@ fn c40_l354_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 356 fn c41_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c41_l356_action_invoke"); - let result = instance.call("as-call-first", &[Value::I32(3 as i32), Value::I32(1 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "as-call-first", + &[ + Value::I32(3 as i32), + Value::I32(1 as i32), + Value::I32(2 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); result.map(|_| ()) } @@ -978,7 +984,14 @@ fn c41_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 357 fn c42_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c42_l357_action_invoke"); - let result = instance.call("as-call-mid1", &[Value::I32(3 as i32), Value::I32(1 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "as-call-mid1", + &[ + Value::I32(3 as i32), + Value::I32(1 as i32), + Value::I32(2 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); result.map(|_| ()) } @@ -986,7 +999,14 @@ fn c42_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 358 fn c43_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c43_l358_action_invoke"); - let result = instance.call("as-call-mid2", &[Value::I32(0 as i32), Value::I32(3 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "as-call-mid2", + &[ + Value::I32(0 as i32), + Value::I32(3 as i32), + Value::I32(1 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); result.map(|_| ()) } @@ -994,7 +1014,14 @@ fn c43_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 359 fn c44_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c44_l359_action_invoke"); - let result = instance.call("as-call-last", &[Value::I32(10 as i32), Value::I32(9 as i32), Value::I32(-1 as i32)]); + let result = instance.call( + "as-call-last", + &[ + Value::I32(10 as i32), + Value::I32(9 as i32), + Value::I32(-1 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(20 as i32)))); result.map(|_| ()) } @@ -1002,7 +1029,14 @@ fn c44_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 360 fn c45_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c45_l360_action_invoke"); - let result = instance.call("as-call-everywhere", &[Value::I32(2 as i32), Value::I32(1 as i32), Value::I32(5 as i32)]); + let result = instance.call( + "as-call-everywhere", + &[ + Value::I32(2 as i32), + Value::I32(1 as i32), + Value::I32(5 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(-2 as i32)))); result.map(|_| ()) } @@ -1282,7 +1316,10 @@ fn c79_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 406 fn c80_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c80_l406_action_invoke"); - let result = instance.call("as-store-first", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "as-store-first", + &[Value::I32(0 as i32), Value::I32(1 as i32)], + ); assert_eq!(result, Ok(None)); result.map(|_| ()) } @@ -1290,7 +1327,10 @@ fn c80_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 407 fn c81_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c81_l407_action_invoke"); - let result = instance.call("as-store-mid", &[Value::I32(0 as i32), Value::I32(2 as i32)]); + let result = instance.call( + "as-store-mid", + &[Value::I32(0 as i32), Value::I32(2 as i32)], + ); assert_eq!(result, Ok(None)); result.map(|_| ()) } @@ -1298,7 +1338,10 @@ fn c81_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 408 fn c82_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c82_l408_action_invoke"); - let result = instance.call("as-store-last", &[Value::I32(0 as i32), Value::I32(3 as i32)]); + let result = instance.call( + "as-store-last", + &[Value::I32(0 as i32), Value::I32(3 as i32)], + ); assert_eq!(result, Ok(None)); result.map(|_| ()) } @@ -1306,7 +1349,10 @@ fn c82_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 409 fn c83_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c83_l409_action_invoke"); - let result = instance.call("as-store-everywhere", &[Value::I32(0 as i32), Value::I32(4 as i32)]); + let result = instance.call( + "as-store-everywhere", + &[Value::I32(0 as i32), Value::I32(4 as i32)], + ); assert_eq!(result, Ok(None)); result.map(|_| ()) } @@ -1314,7 +1360,9 @@ fn c83_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 412 #[test] fn c84_l412_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1322,7 +1370,9 @@ fn c84_l412_assert_invalid() { // Line 416 #[test] fn c85_l416_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1330,7 +1380,9 @@ fn c85_l416_assert_invalid() { // Line 420 #[test] fn c86_l420_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1338,7 +1390,9 @@ fn c86_l420_assert_invalid() { // Line 424 #[test] fn c87_l424_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/return_.rs b/lib/runtime/tests/spectests/return_.rs index e26e52349..9924494bc 100644 --- a/lib/runtime/tests/spectests/return_.rs +++ b/lib/runtime/tests/spectests/return_.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -418,8 +414,11 @@ fn create_module_1() -> Box { (elem (;0;) (i32.const 0) 36)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -702,7 +701,10 @@ fn c34_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 262 fn c35_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c35_l262_action_invoke"); - let result = instance.call("as-select-first", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + let result = instance.call( + "as-select-first", + &[Value::I32(0 as i32), Value::I32(6 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); result.map(|_| ()) } @@ -710,7 +712,10 @@ fn c35_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 263 fn c36_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c36_l263_action_invoke"); - let result = instance.call("as-select-first", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + let result = instance.call( + "as-select-first", + &[Value::I32(1 as i32), Value::I32(6 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); result.map(|_| ()) } @@ -718,7 +723,10 @@ fn c36_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 264 fn c37_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c37_l264_action_invoke"); - let result = instance.call("as-select-second", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + let result = instance.call( + "as-select-second", + &[Value::I32(0 as i32), Value::I32(6 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); result.map(|_| ()) } @@ -726,7 +734,10 @@ fn c37_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 265 fn c38_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c38_l265_action_invoke"); - let result = instance.call("as-select-second", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + let result = instance.call( + "as-select-second", + &[Value::I32(1 as i32), Value::I32(6 as i32)], + ); assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); result.map(|_| ()) } @@ -918,7 +929,9 @@ fn c61_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 302 #[test] fn c62_l302_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 5, 1, 3, 0, 15, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 5, 1, 3, 0, 15, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -926,7 +939,9 @@ fn c62_l302_assert_invalid() { // Line 306 #[test] fn c63_l306_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 6, 1, 4, 0, 1, 15, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 6, 1, 4, 0, 1, 15, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -934,7 +949,10 @@ fn c63_l306_assert_invalid() { // Line 310 #[test] fn c64_l310_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 1, 15, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 1, 15, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/select.rs b/lib/runtime/tests/spectests/select.rs index afe8287cf..9b230e464 100644 --- a/lib/runtime/tests/spectests/select.rs +++ b/lib/runtime/tests/spectests/select.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { @@ -81,8 +77,11 @@ fn create_module_1() -> Box { (export \"select_unreached\" (func 6))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -93,7 +92,14 @@ fn start_module_1(instance: &mut Instance) { // Line 31 fn c1_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1_l31_action_invoke"); - let result = instance.call("select_i32", &[Value::I32(1 as i32), Value::I32(2 as i32), Value::I32(1 as i32)]); + let result = instance.call( + "select_i32", + &[ + Value::I32(1 as i32), + Value::I32(2 as i32), + Value::I32(1 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -101,7 +107,14 @@ fn c1_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 32 fn c2_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2_l32_action_invoke"); - let result = instance.call("select_i64", &[Value::I64(2 as i64), Value::I64(1 as i64), Value::I32(1 as i32)]); + let result = instance.call( + "select_i64", + &[ + Value::I64(2 as i64), + Value::I64(1 as i64), + Value::I32(1 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); result.map(|_| ()) } @@ -109,7 +122,14 @@ fn c2_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 33 fn c3_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c3_l33_action_invoke"); - let result = instance.call("select_f32", &[Value::F32((1.0f32)), Value::F32((2.0f32)), Value::I32(1 as i32)]); + let result = instance.call( + "select_f32", + &[ + Value::F32((1.0f32)), + Value::F32((2.0f32)), + Value::I32(1 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -117,7 +137,14 @@ fn c3_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 34 fn c4_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c4_l34_action_invoke"); - let result = instance.call("select_f64", &[Value::F64((1.0f64)), Value::F64((2.0f64)), Value::I32(1 as i32)]); + let result = instance.call( + "select_f64", + &[ + Value::F64((1.0f64)), + Value::F64((2.0f64)), + Value::I32(1 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -125,7 +152,14 @@ fn c4_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 36 fn c5_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c5_l36_action_invoke"); - let result = instance.call("select_i32", &[Value::I32(1 as i32), Value::I32(2 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "select_i32", + &[ + Value::I32(1 as i32), + Value::I32(2 as i32), + Value::I32(0 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); result.map(|_| ()) } @@ -133,7 +167,14 @@ fn c5_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 37 fn c6_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c6_l37_action_invoke"); - let result = instance.call("select_i32", &[Value::I32(2 as i32), Value::I32(1 as i32), Value::I32(0 as i32)]); + let result = instance.call( + "select_i32", + &[ + Value::I32(2 as i32), + Value::I32(1 as i32), + Value::I32(0 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); result.map(|_| ()) } @@ -141,7 +182,14 @@ fn c6_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 38 fn c7_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c7_l38_action_invoke"); - let result = instance.call("select_i64", &[Value::I64(2 as i64), Value::I64(1 as i64), Value::I32(-1 as i32)]); + let result = instance.call( + "select_i64", + &[ + Value::I64(2 as i64), + Value::I64(1 as i64), + Value::I32(-1 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); result.map(|_| ()) } @@ -149,7 +197,14 @@ fn c7_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 39 fn c8_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c8_l39_action_invoke"); - let result = instance.call("select_i64", &[Value::I64(2 as i64), Value::I64(1 as i64), Value::I32(-252645136 as i32)]); + let result = instance.call( + "select_i64", + &[ + Value::I64(2 as i64), + Value::I64(1 as i64), + Value::I32(-252645136 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); result.map(|_| ()) } @@ -157,35 +212,62 @@ fn c8_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 41 fn c9_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c9_l41_action_invoke"); - let result = instance.call("select_f32", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32)), Value::I32(1 as i32)]); + let result = instance.call( + "select_f32", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((1.0f32)), + Value::I32(1 as i32), + ], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 42 fn c10_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c10_l42_action_invoke"); - let result = instance.call("select_f32", &[Value::F32(f32::from_bits(2139226884)), Value::F32((1.0f32)), Value::I32(1 as i32)]); + let result = instance.call( + "select_f32", + &[ + Value::F32(f32::from_bits(2139226884)), + Value::F32((1.0f32)), + Value::I32(1 as i32), + ], + ); let expected = f32::from_bits(2139226884); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 43 fn c11_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c11_l43_action_invoke"); - let result = instance.call("select_f32", &[Value::F32(f32::from_bits(2143289344)), Value::F32((1.0f32)), Value::I32(0 as i32)]); + let result = instance.call( + "select_f32", + &[ + Value::F32(f32::from_bits(2143289344)), + Value::F32((1.0f32)), + Value::I32(0 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -193,7 +275,14 @@ fn c11_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 44 fn c12_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c12_l44_action_invoke"); - let result = instance.call("select_f32", &[Value::F32(f32::from_bits(2139226884)), Value::F32((1.0f32)), Value::I32(0 as i32)]); + let result = instance.call( + "select_f32", + &[ + Value::F32(f32::from_bits(2139226884)), + Value::F32((1.0f32)), + Value::I32(0 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::F32((1.0f32))))); result.map(|_| ()) } @@ -201,7 +290,14 @@ fn c12_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 45 fn c13_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c13_l45_action_invoke"); - let result = instance.call("select_f32", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344)), Value::I32(1 as i32)]); + let result = instance.call( + "select_f32", + &[ + Value::F32((2.0f32)), + Value::F32(f32::from_bits(2143289344)), + Value::I32(1 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::F32((2.0f32))))); result.map(|_| ()) } @@ -209,7 +305,14 @@ fn c13_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 46 fn c14_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c14_l46_action_invoke"); - let result = instance.call("select_f32", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2139226884)), Value::I32(1 as i32)]); + let result = instance.call( + "select_f32", + &[ + Value::F32((2.0f32)), + Value::F32(f32::from_bits(2139226884)), + Value::I32(1 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::F32((2.0f32))))); result.map(|_| ()) } @@ -217,63 +320,110 @@ fn c14_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 47 fn c15_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c15_l47_action_invoke"); - let result = instance.call("select_f32", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2143289344)), Value::I32(0 as i32)]); + let result = instance.call( + "select_f32", + &[ + Value::F32((2.0f32)), + Value::F32(f32::from_bits(2143289344)), + Value::I32(0 as i32), + ], + ); let expected = f32::from_bits(2143289344); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 48 fn c16_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c16_l48_action_invoke"); - let result = instance.call("select_f32", &[Value::F32((2.0f32)), Value::F32(f32::from_bits(2139226884)), Value::I32(0 as i32)]); + let result = instance.call( + "select_f32", + &[ + Value::F32((2.0f32)), + Value::F32(f32::from_bits(2139226884)), + Value::I32(0 as i32), + ], + ); let expected = f32::from_bits(2139226884); - if let Value::F32(result) = result.clone().unwrap().unwrap() { - assert!((result as f32).is_nan()); - assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F32(result) = result.clone().unwrap().unwrap() { + assert!((result as f32).is_nan()); + assert_eq!( + (result as f32).is_sign_positive(), + (expected as f32).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 50 fn c17_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c17_l50_action_invoke"); - let result = instance.call("select_f64", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64)), Value::I32(1 as i32)]); + let result = instance.call( + "select_f64", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + Value::I32(1 as i32), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 51 fn c18_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c18_l51_action_invoke"); - let result = instance.call("select_f64", &[Value::F64(f64::from_bits(9218868437227537156)), Value::F64((1.0f64)), Value::I32(1 as i32)]); + let result = instance.call( + "select_f64", + &[ + Value::F64(f64::from_bits(9218868437227537156)), + Value::F64((1.0f64)), + Value::I32(1 as i32), + ], + ); let expected = f64::from_bits(9218868437227537156); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 52 fn c19_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c19_l52_action_invoke"); - let result = instance.call("select_f64", &[Value::F64(f64::from_bits(9221120237041090560)), Value::F64((1.0f64)), Value::I32(0 as i32)]); + let result = instance.call( + "select_f64", + &[ + Value::F64(f64::from_bits(9221120237041090560)), + Value::F64((1.0f64)), + Value::I32(0 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -281,7 +431,14 @@ fn c19_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 53 fn c20_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c20_l53_action_invoke"); - let result = instance.call("select_f64", &[Value::F64(f64::from_bits(9218868437227537156)), Value::F64((1.0f64)), Value::I32(0 as i32)]); + let result = instance.call( + "select_f64", + &[ + Value::F64(f64::from_bits(9218868437227537156)), + Value::F64((1.0f64)), + Value::I32(0 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::F64((1.0f64))))); result.map(|_| ()) } @@ -289,7 +446,14 @@ fn c20_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 54 fn c21_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c21_l54_action_invoke"); - let result = instance.call("select_f64", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9221120237041090560)), Value::I32(1 as i32)]); + let result = instance.call( + "select_f64", + &[ + Value::F64((2.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + Value::I32(1 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::F64((2.0f64))))); result.map(|_| ()) } @@ -297,7 +461,14 @@ fn c21_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 55 fn c22_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c22_l55_action_invoke"); - let result = instance.call("select_f64", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9218868437227537156)), Value::I32(1 as i32)]); + let result = instance.call( + "select_f64", + &[ + Value::F64((2.0f64)), + Value::F64(f64::from_bits(9218868437227537156)), + Value::I32(1 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::F64((2.0f64))))); result.map(|_| ()) } @@ -305,28 +476,48 @@ fn c22_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 56 fn c23_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c23_l56_action_invoke"); - let result = instance.call("select_f64", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9221120237041090560)), Value::I32(0 as i32)]); + let result = instance.call( + "select_f64", + &[ + Value::F64((2.0f64)), + Value::F64(f64::from_bits(9221120237041090560)), + Value::I32(0 as i32), + ], + ); let expected = f64::from_bits(9221120237041090560); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } // Line 57 fn c24_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c24_l57_action_invoke"); - let result = instance.call("select_f64", &[Value::F64((2.0f64)), Value::F64(f64::from_bits(9218868437227537156)), Value::I32(0 as i32)]); + let result = instance.call( + "select_f64", + &[ + Value::F64((2.0f64)), + Value::F64(f64::from_bits(9218868437227537156)), + Value::I32(0 as i32), + ], + ); let expected = f64::from_bits(9218868437227537156); - if let Value::F64(result) = result.clone().unwrap().unwrap() { - assert!((result as f64).is_nan()); - assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); - } else { - panic!("Unexpected result type {:?}", result); - } + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!( + (result as f64).is_sign_positive(), + (expected as f64).is_sign_positive() + ); + } else { + panic!("Unexpected result type {:?}", result); + } result.map(|_| ()) } @@ -334,14 +525,14 @@ fn c24_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c25_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c25_l59_action_invoke"); let result = instance.call("select_trap_l", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c25_l59_assert_trap() { let mut instance = create_module_1(); - let result = c25_l59_action_invoke(&mut*instance); + let result = c25_l59_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -349,14 +540,14 @@ fn c25_l59_assert_trap() { fn c26_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c26_l60_action_invoke"); let result = instance.call("select_trap_l", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c26_l60_assert_trap() { let mut instance = create_module_1(); - let result = c26_l60_action_invoke(&mut*instance); + let result = c26_l60_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -364,14 +555,14 @@ fn c26_l60_assert_trap() { fn c27_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c27_l61_action_invoke"); let result = instance.call("select_trap_r", &[Value::I32(1 as i32)]); - + result.map(|_| ()) } #[test] fn c27_l61_assert_trap() { let mut instance = create_module_1(); - let result = c27_l61_action_invoke(&mut*instance); + let result = c27_l61_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -379,21 +570,24 @@ fn c27_l61_assert_trap() { fn c28_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c28_l62_action_invoke"); let result = instance.call("select_trap_r", &[Value::I32(0 as i32)]); - + result.map(|_| ()) } #[test] fn c28_l62_assert_trap() { let mut instance = create_module_1(); - let result = c28_l62_action_invoke(&mut*instance); + let result = c28_l62_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 65 #[test] fn c29_l65_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 1, 1, 65, 1, 27, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 1, 1, 65, 1, + 27, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/set_local.rs b/lib/runtime/tests/spectests/set_local.rs index 0ca235a8d..baf0ded06 100644 --- a/lib/runtime/tests/spectests/set_local.rs +++ b/lib/runtime/tests/spectests/set_local.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -127,8 +123,11 @@ fn create_module_1() -> Box { (export \"write\" (func 9))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -203,7 +202,16 @@ fn c8_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 79 fn c9_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c9_l79_action_invoke"); - let result = instance.call("type-mixed", &[Value::I64(1 as i64), Value::F32((2.2f32)), Value::F64((3.3f64)), Value::I32(4 as i32), Value::I32(5 as i32)]); + let result = instance.call( + "type-mixed", + &[ + Value::I64(1 as i64), + Value::F32((2.2f32)), + Value::F64((3.3f64)), + Value::I32(4 as i32), + Value::I32(5 as i32), + ], + ); assert_eq!(result, Ok(None)); result.map(|_| ()) } @@ -211,7 +219,16 @@ fn c9_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 85 fn c10_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c10_l85_action_invoke"); - let result = instance.call("write", &[Value::I64(1 as i64), Value::F32((2.0f32)), Value::F64((3.3f64)), Value::I32(4 as i32), Value::I32(5 as i32)]); + let result = instance.call( + "write", + &[ + Value::I64(1 as i64), + Value::F32((2.0f32)), + Value::F64((3.3f64)), + Value::I32(4 as i32), + Value::I32(5 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I64(56 as i64)))); result.map(|_| ()) } @@ -219,7 +236,10 @@ fn c10_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 95 #[test] fn c11_l95_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 10, 1, 8, 1, 1, 127, 65, 0, 33, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 10, 1, 8, 1, 1, 127, + 65, 0, 33, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -227,7 +247,10 @@ fn c11_l95_assert_invalid() { // Line 101 #[test] fn c12_l101_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 1, 1, 125, 67, 0, 0, 0, 0, 33, 0, 69, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 1, 1, 125, 67, + 0, 0, 0, 0, 33, 0, 69, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -235,7 +258,10 @@ fn c12_l101_assert_invalid() { // Line 107 #[test] fn c13_l107_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 124, 1, 126, 66, 0, 33, 1, 154, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 124, 1, + 126, 66, 0, 33, 1, 154, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -243,7 +269,10 @@ fn c13_l107_assert_invalid() { // Line 114 #[test] fn c14_l114_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 1, 1, 127, 1, 33, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 1, 1, 127, 1, 33, + 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -251,7 +280,10 @@ fn c14_l114_assert_invalid() { // Line 118 #[test] fn c15_l118_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, 67, 0, 0, 0, 0, 33, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, 67, + 0, 0, 0, 0, 33, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -259,7 +291,10 @@ fn c15_l118_assert_invalid() { // Line 122 #[test] fn c16_l122_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 17, 1, 15, 1, 1, 125, 68, 0, 0, 0, 0, 0, 0, 0, 0, 33, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 17, 1, 15, 1, 1, 125, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 33, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -267,7 +302,10 @@ fn c16_l122_assert_invalid() { // Line 126 #[test] fn c17_l126_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 19, 1, 17, 2, 1, 124, 1, 126, 68, 0, 0, 0, 0, 0, 0, 0, 0, 33, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 19, 1, 17, 2, 1, 124, 1, + 126, 68, 0, 0, 0, 0, 0, 0, 0, 0, 33, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -275,7 +313,10 @@ fn c17_l126_assert_invalid() { // Line 134 #[test] fn c18_l134_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 126, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 126, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, + 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -283,7 +324,10 @@ fn c18_l134_assert_invalid() { // Line 138 #[test] fn c19_l138_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 0, 69, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 0, 69, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -291,7 +335,10 @@ fn c19_l138_assert_invalid() { // Line 142 #[test] fn c20_l142_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 1, 154, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, + 1, 154, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -299,7 +346,10 @@ fn c20_l142_assert_invalid() { // Line 147 #[test] fn c21_l147_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 1, 33, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 1, 33, 0, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -307,7 +357,10 @@ fn c21_l147_assert_invalid() { // Line 151 #[test] fn c22_l151_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 67, 0, 0, 0, 0, 33, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 67, 0, 0, + 0, 0, 33, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -315,7 +368,10 @@ fn c22_l151_assert_invalid() { // Line 155 #[test] fn c23_l155_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 33, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 33, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -323,7 +379,10 @@ fn c23_l155_assert_invalid() { // Line 159 #[test] fn c24_l159_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 33, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 33, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -331,7 +390,10 @@ fn c24_l159_assert_invalid() { // Line 167 #[test] fn c25_l167_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, 126, 32, 3, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, + 126, 32, 3, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -339,7 +401,10 @@ fn c25_l167_assert_invalid() { // Line 171 #[test] fn c26_l171_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, 126, 32, 247, 164, 234, 6, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, + 126, 32, 247, 164, 234, 6, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -347,7 +412,10 @@ fn c26_l171_assert_invalid() { // Line 176 #[test] fn c27_l176_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 127, 126, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, 2, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 127, 126, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, + 2, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -355,7 +423,10 @@ fn c27_l176_assert_invalid() { // Line 180 #[test] fn c28_l180_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 2, 1, 127, 1, 126, 32, 247, 242, 206, 212, 2, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 2, 1, 127, 1, + 126, 32, 247, 242, 206, 212, 2, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -363,7 +434,10 @@ fn c28_l180_assert_invalid() { // Line 185 #[test] fn c29_l185_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, 126, 32, 3, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, + 1, 126, 32, 3, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -371,7 +445,10 @@ fn c29_l185_assert_invalid() { // Line 189 #[test] fn c30_l189_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, 126, 32, 247, 168, 153, 102, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, + 1, 126, 32, 247, 168, 153, 102, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -379,7 +456,10 @@ fn c30_l189_assert_invalid() { // Line 194 #[test] fn c31_l194_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, 67, 0, 0, 0, 0, 33, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, + 67, 0, 0, 0, 0, 33, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -387,7 +467,10 @@ fn c31_l194_assert_invalid() { // Line 198 #[test] fn c32_l198_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 126, 127, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 125, 67, 0, 0, 0, 0, 33, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 126, 127, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, + 125, 67, 0, 0, 0, 0, 33, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -395,7 +478,10 @@ fn c32_l198_assert_invalid() { // Line 202 #[test] fn c33_l202_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 12, 1, 10, 2, 1, 124, 1, 126, 66, 0, 33, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 12, 1, 10, 2, 1, 124, + 1, 126, 66, 0, 33, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/stack.rs b/lib/runtime/tests/spectests/stack.rs index 5c5995f8b..0c530803f 100644 --- a/lib/runtime/tests/spectests/stack.rs +++ b/lib/runtime/tests/spectests/stack.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { @@ -164,8 +160,11 @@ fn create_module_1() -> Box { (export \"fac-mixed-raw\" (func 4))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -435,8 +434,11 @@ fn create_module_2() -> Box { (table (;0;) 1 anyfunc)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { diff --git a/lib/runtime/tests/spectests/start.rs b/lib/runtime/tests/spectests/start.rs index 264985048..e105e00f6 100644 --- a/lib/runtime/tests/spectests/start.rs +++ b/lib/runtime/tests/spectests/start.rs @@ -5,23 +5,21 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 2 #[test] fn c0_l2_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 8, 1, 1, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 8, 1, 1, 10, 4, 1, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -29,7 +27,10 @@ fn c0_l2_assert_invalid() { // Line 7 #[test] fn c1_l7_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 8, 1, 0, 10, 7, 1, 5, 0, 65, 0, 15, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 8, 1, 0, 10, 7, 1, 5, 0, + 65, 0, 15, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -37,7 +38,10 @@ fn c1_l7_assert_invalid() { // Line 14 #[test] fn c2_l14_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 8, 1, 0, 10, 4, 1, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 8, 1, 0, 10, 4, 1, 2, 0, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -69,8 +73,11 @@ fn create_module_1() -> Box { (data (;0;) (i32.const 0) \"A\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -90,7 +97,7 @@ fn c4_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c5_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c5_l46_action_invoke"); let result = instance.call("inc", &[]); - + result.map(|_| ()) } @@ -106,7 +113,7 @@ fn c6_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c7_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c7_l48_action_invoke"); let result = instance.call("inc", &[]); - + result.map(|_| ()) } @@ -157,8 +164,11 @@ fn create_module_2() -> Box { (data (;0;) (i32.const 0) \"A\")) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -178,7 +188,7 @@ fn c10_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c11_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c11_l75_action_invoke"); let result = instance.call("inc", &[]); - + result.map(|_| ()) } @@ -194,7 +204,7 @@ fn c12_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c13_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c13_l77_action_invoke"); let result = instance.call("inc", &[]); - + result.map(|_| ()) } @@ -230,8 +240,11 @@ fn create_module_3() -> Box { (start 1)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -258,8 +271,11 @@ fn create_module_4() -> Box { (start 1)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { @@ -282,8 +298,11 @@ fn create_module_5() -> Box { (start 0)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_5(instance: &mut Instance) { diff --git a/lib/runtime/tests/spectests/store_retval.rs b/lib/runtime/tests/spectests/store_retval.rs index 067ce1f72..58845767e 100644 --- a/lib/runtime/tests/spectests/store_retval.rs +++ b/lib/runtime/tests/spectests/store_retval.rs @@ -5,23 +5,22 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 2 #[test] fn c0_l2_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 65, 1, 33, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 65, + 1, 33, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -29,7 +28,10 @@ fn c0_l2_assert_invalid() { // Line 6 #[test] fn c1_l6_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 10, 8, 1, 6, 0, 66, 1, 33, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 10, 8, 1, 6, 0, 66, + 1, 33, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -37,7 +39,10 @@ fn c1_l6_assert_invalid() { // Line 10 #[test] fn c2_l10_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 125, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 67, 0, 0, 128, 63, 33, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 125, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 67, + 0, 0, 128, 63, 33, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -45,7 +50,10 @@ fn c2_l10_assert_invalid() { // Line 14 #[test] fn c3_l14_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 124, 1, 124, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 33, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 124, 1, 124, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, + 0, 0, 0, 0, 0, 0, 240, 63, 33, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -53,7 +61,10 @@ fn c3_l14_assert_invalid() { // Line 19 #[test] fn c4_l19_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 65, 1, 54, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, + 11, 1, 9, 0, 65, 0, 65, 1, 54, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -61,7 +72,10 @@ fn c4_l19_assert_invalid() { // Line 23 #[test] fn c5_l23_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 66, 1, 55, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, + 11, 1, 9, 0, 65, 0, 66, 1, 55, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -69,7 +83,10 @@ fn c5_l23_assert_invalid() { // Line 27 #[test] fn c6_l27_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 125, 1, 125, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 65, 0, 67, 0, 0, 128, 63, 56, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 125, 1, 125, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, + 14, 1, 12, 0, 65, 0, 67, 0, 0, 128, 63, 56, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -77,7 +94,10 @@ fn c6_l27_assert_invalid() { // Line 31 #[test] fn c7_l31_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 124, 1, 124, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 18, 1, 16, 0, 65, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 57, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 124, 1, 124, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, + 18, 1, 16, 0, 65, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 57, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -85,7 +105,10 @@ fn c7_l31_assert_invalid() { // Line 36 #[test] fn c8_l36_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 65, 1, 58, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, + 11, 1, 9, 0, 65, 0, 65, 1, 58, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -93,7 +116,10 @@ fn c8_l36_assert_invalid() { // Line 40 #[test] fn c9_l40_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 65, 1, 59, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, + 11, 1, 9, 0, 65, 0, 65, 1, 59, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -101,7 +127,10 @@ fn c9_l40_assert_invalid() { // Line 44 #[test] fn c10_l44_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 66, 1, 60, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, + 11, 1, 9, 0, 65, 0, 66, 1, 60, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -109,7 +138,10 @@ fn c10_l44_assert_invalid() { // Line 48 #[test] fn c11_l48_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 66, 1, 61, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, + 11, 1, 9, 0, 65, 0, 66, 1, 61, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -117,7 +149,10 @@ fn c11_l48_assert_invalid() { // Line 52 #[test] fn c12_l52_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 66, 1, 62, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, + 11, 1, 9, 0, 65, 0, 66, 1, 62, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/switch.rs b/lib/runtime/tests/spectests/switch.rs index 245548725..a09a6a89f 100644 --- a/lib/runtime/tests/spectests/switch.rs +++ b/lib/runtime/tests/spectests/switch.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 1 fn create_module_1() -> Box { @@ -143,8 +139,11 @@ fn create_module_1() -> Box { (export \"corner\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -363,7 +362,10 @@ fn c26_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 150 #[test] fn c27_l150_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 14, 0, 3, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 14, 0, + 3, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/tee_local.rs b/lib/runtime/tests/spectests/tee_local.rs index e664f4160..585ce1bc8 100644 --- a/lib/runtime/tests/spectests/tee_local.rs +++ b/lib/runtime/tests/spectests/tee_local.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -191,8 +187,11 @@ fn create_module_1() -> Box { (export \"result\" (func 10))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -267,7 +266,16 @@ fn c8_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 109 fn c9_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c9_l109_action_invoke"); - let result = instance.call("type-mixed", &[Value::I64(1 as i64), Value::F32((2.2f32)), Value::F64((3.3f64)), Value::I32(4 as i32), Value::I32(5 as i32)]); + let result = instance.call( + "type-mixed", + &[ + Value::I64(1 as i64), + Value::F32((2.2f32)), + Value::F64((3.3f64)), + Value::I32(4 as i32), + Value::I32(5 as i32), + ], + ); assert_eq!(result, Ok(None)); result.map(|_| ()) } @@ -275,7 +283,16 @@ fn c9_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 115 fn c10_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c10_l115_action_invoke"); - let result = instance.call("write", &[Value::I64(1 as i64), Value::F32((2.0f32)), Value::F64((3.3f64)), Value::I32(4 as i32), Value::I32(5 as i32)]); + let result = instance.call( + "write", + &[ + Value::I64(1 as i64), + Value::F32((2.0f32)), + Value::F64((3.3f64)), + Value::I32(4 as i32), + Value::I32(5 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::I64(56 as i64)))); result.map(|_| ()) } @@ -283,7 +300,16 @@ fn c10_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 122 fn c11_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c11_l122_action_invoke"); - let result = instance.call("result", &[Value::I64(-1 as i64), Value::F32((-2.0f32)), Value::F64((-3.3f64)), Value::I32(-4 as i32), Value::I32(-5 as i32)]); + let result = instance.call( + "result", + &[ + Value::I64(-1 as i64), + Value::F32((-2.0f32)), + Value::F64((-3.3f64)), + Value::I32(-4 as i32), + Value::I32(-5 as i32), + ], + ); assert_eq!(result, Ok(Some(Value::F64((34.8f64))))); result.map(|_| ()) } @@ -291,7 +317,10 @@ fn c11_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { // Line 132 #[test] fn c12_l132_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 10, 1, 8, 1, 1, 127, 65, 0, 34, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 10, 1, 8, 1, 1, 127, + 65, 0, 34, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -299,7 +328,10 @@ fn c12_l132_assert_invalid() { // Line 136 #[test] fn c13_l136_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 1, 1, 125, 67, 0, 0, 0, 0, 34, 0, 69, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 1, 1, 125, 67, + 0, 0, 0, 0, 34, 0, 69, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -307,7 +339,10 @@ fn c13_l136_assert_invalid() { // Line 140 #[test] fn c14_l140_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 124, 1, 126, 66, 0, 34, 1, 154, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 124, 1, + 126, 66, 0, 34, 1, 154, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -315,7 +350,10 @@ fn c14_l140_assert_invalid() { // Line 145 #[test] fn c15_l145_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 1, 1, 127, 1, 34, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 1, 1, 127, 1, 34, + 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -323,7 +361,10 @@ fn c15_l145_assert_invalid() { // Line 149 #[test] fn c16_l149_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, 67, 0, 0, 0, 0, 34, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, 67, + 0, 0, 0, 0, 34, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -331,7 +372,10 @@ fn c16_l149_assert_invalid() { // Line 153 #[test] fn c17_l153_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 17, 1, 15, 1, 1, 125, 68, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 17, 1, 15, 1, 1, 125, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -339,7 +383,10 @@ fn c17_l153_assert_invalid() { // Line 157 #[test] fn c18_l157_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 19, 1, 17, 2, 1, 124, 1, 126, 68, 0, 0, 0, 0, 0, 0, 0, 0, 34, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 19, 1, 17, 2, 1, 124, 1, + 126, 68, 0, 0, 0, 0, 0, 0, 0, 0, 34, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -347,7 +394,10 @@ fn c18_l157_assert_invalid() { // Line 165 #[test] fn c19_l165_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 126, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 126, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, + 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -355,7 +405,10 @@ fn c19_l165_assert_invalid() { // Line 169 #[test] fn c20_l169_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 0, 69, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 0, 69, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -363,7 +416,10 @@ fn c20_l169_assert_invalid() { // Line 173 #[test] fn c21_l173_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 1, 154, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, + 1, 154, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -371,7 +427,10 @@ fn c21_l173_assert_invalid() { // Line 178 #[test] fn c22_l178_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 1, 34, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 1, 34, 0, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -379,7 +438,10 @@ fn c22_l178_assert_invalid() { // Line 182 #[test] fn c23_l182_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 67, 0, 0, 0, 0, 34, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 67, 0, 0, + 0, 0, 34, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -387,7 +449,10 @@ fn c23_l182_assert_invalid() { // Line 186 #[test] fn c24_l186_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 34, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -395,7 +460,10 @@ fn c24_l186_assert_invalid() { // Line 190 #[test] fn c25_l190_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 34, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 34, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -403,7 +471,10 @@ fn c25_l190_assert_invalid() { // Line 198 #[test] fn c26_l198_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, 126, 32, 3, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, + 126, 32, 3, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -411,7 +482,10 @@ fn c26_l198_assert_invalid() { // Line 202 #[test] fn c27_l202_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, 126, 32, 247, 164, 234, 6, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, + 126, 32, 247, 164, 234, 6, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -419,7 +493,10 @@ fn c27_l202_assert_invalid() { // Line 207 #[test] fn c28_l207_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 127, 126, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, 2, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 127, 126, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, + 2, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -427,7 +504,10 @@ fn c28_l207_assert_invalid() { // Line 211 #[test] fn c29_l211_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 2, 1, 127, 1, 126, 32, 247, 242, 206, 212, 2, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 2, 1, 127, 1, + 126, 32, 247, 242, 206, 212, 2, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -435,7 +515,10 @@ fn c29_l211_assert_invalid() { // Line 216 #[test] fn c30_l216_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, 126, 32, 3, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, + 1, 126, 32, 3, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -443,7 +526,10 @@ fn c30_l216_assert_invalid() { // Line 220 #[test] fn c31_l220_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, 126, 32, 247, 168, 153, 102, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, + 1, 126, 32, 247, 168, 153, 102, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -451,7 +537,10 @@ fn c31_l220_assert_invalid() { // Line 225 #[test] fn c32_l225_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, 67, 0, 0, 0, 0, 34, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, + 67, 0, 0, 0, 0, 34, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -459,7 +548,10 @@ fn c32_l225_assert_invalid() { // Line 229 #[test] fn c33_l229_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 126, 127, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 125, 67, 0, 0, 0, 0, 34, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 126, 127, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, + 125, 67, 0, 0, 0, 0, 34, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -467,7 +559,10 @@ fn c33_l229_assert_invalid() { // Line 233 #[test] fn c34_l233_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 12, 1, 10, 2, 1, 124, 1, 126, 66, 0, 34, 1, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 12, 1, 10, 2, 1, 124, + 1, 126, 66, 0, 34, 1, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/token.rs b/lib/runtime/tests/spectests/token.rs index fd0a124a0..b8ba7435f 100644 --- a/lib/runtime/tests/spectests/token.rs +++ b/lib/runtime/tests/spectests/token.rs @@ -5,31 +5,38 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 4 #[test] fn c0_l4_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 48, 41, 41, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 99, 111, 110, + 115, 116, 48, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 8 #[test] fn c1_l8_assert_malformed() { - let wasm_binary = [40, 102, 117, 110, 99, 32, 98, 114, 32, 48, 100, 114, 111, 112, 41]; + let wasm_binary = [ + 40, 102, 117, 110, 99, 32, 98, 114, 32, 48, 100, 114, 111, 112, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } diff --git a/lib/runtime/tests/spectests/traps.rs b/lib/runtime/tests/spectests/traps.rs index f4b084d77..64519a573 100644 --- a/lib/runtime/tests/spectests/traps.rs +++ b/lib/runtime/tests/spectests/traps.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 5 fn create_module_1() -> Box { @@ -49,8 +45,11 @@ fn create_module_1() -> Box { (export \"no_dce.i64.div_u\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -61,90 +60,111 @@ fn start_module_1(instance: &mut Instance) { // Line 16 fn c1_l16_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1_l16_action_invoke"); - let result = instance.call("no_dce.i32.div_s", &[Value::I32(1 as i32), Value::I32(0 as i32)]); - + let result = instance.call( + "no_dce.i32.div_s", + &[Value::I32(1 as i32), Value::I32(0 as i32)], + ); + result.map(|_| ()) } #[test] fn c1_l16_assert_trap() { let mut instance = create_module_1(); - let result = c1_l16_action_invoke(&mut*instance); + let result = c1_l16_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 17 fn c2_l17_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c2_l17_action_invoke"); - let result = instance.call("no_dce.i32.div_u", &[Value::I32(1 as i32), Value::I32(0 as i32)]); - + let result = instance.call( + "no_dce.i32.div_u", + &[Value::I32(1 as i32), Value::I32(0 as i32)], + ); + result.map(|_| ()) } #[test] fn c2_l17_assert_trap() { let mut instance = create_module_1(); - let result = c2_l17_action_invoke(&mut*instance); + let result = c2_l17_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 18 fn c3_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c3_l18_action_invoke"); - let result = instance.call("no_dce.i64.div_s", &[Value::I64(1 as i64), Value::I64(0 as i64)]); - + let result = instance.call( + "no_dce.i64.div_s", + &[Value::I64(1 as i64), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c3_l18_assert_trap() { let mut instance = create_module_1(); - let result = c3_l18_action_invoke(&mut*instance); + let result = c3_l18_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 19 fn c4_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c4_l19_action_invoke"); - let result = instance.call("no_dce.i64.div_u", &[Value::I64(1 as i64), Value::I64(0 as i64)]); - + let result = instance.call( + "no_dce.i64.div_u", + &[Value::I64(1 as i64), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c4_l19_assert_trap() { let mut instance = create_module_1(); - let result = c4_l19_action_invoke(&mut*instance); + let result = c4_l19_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 20 fn c5_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c5_l20_action_invoke"); - let result = instance.call("no_dce.i32.div_s", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); - + let result = instance.call( + "no_dce.i32.div_s", + &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)], + ); + result.map(|_| ()) } #[test] fn c5_l20_assert_trap() { let mut instance = create_module_1(); - let result = c5_l20_action_invoke(&mut*instance); + let result = c5_l20_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 21 fn c6_l21_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c6_l21_action_invoke"); - let result = instance.call("no_dce.i64.div_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); - + let result = instance.call( + "no_dce.i64.div_s", + &[ + Value::I64(-9223372036854775808 as i64), + Value::I64(-1 as i64), + ], + ); + result.map(|_| ()) } #[test] fn c6_l21_assert_trap() { let mut instance = create_module_1(); - let result = c6_l21_action_invoke(&mut*instance); + let result = c6_l21_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -186,8 +206,11 @@ fn create_module_2() -> Box { (export \"no_dce.i64.rem_u\" (func 3))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_2(instance: &mut Instance) { @@ -198,60 +221,72 @@ fn start_module_2(instance: &mut Instance) { // Line 34 fn c8_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c8_l34_action_invoke"); - let result = instance.call("no_dce.i32.rem_s", &[Value::I32(1 as i32), Value::I32(0 as i32)]); - + let result = instance.call( + "no_dce.i32.rem_s", + &[Value::I32(1 as i32), Value::I32(0 as i32)], + ); + result.map(|_| ()) } #[test] fn c8_l34_assert_trap() { let mut instance = create_module_2(); - let result = c8_l34_action_invoke(&mut*instance); + let result = c8_l34_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 35 fn c9_l35_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c9_l35_action_invoke"); - let result = instance.call("no_dce.i32.rem_u", &[Value::I32(1 as i32), Value::I32(0 as i32)]); - + let result = instance.call( + "no_dce.i32.rem_u", + &[Value::I32(1 as i32), Value::I32(0 as i32)], + ); + result.map(|_| ()) } #[test] fn c9_l35_assert_trap() { let mut instance = create_module_2(); - let result = c9_l35_action_invoke(&mut*instance); + let result = c9_l35_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 36 fn c10_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c10_l36_action_invoke"); - let result = instance.call("no_dce.i64.rem_s", &[Value::I64(1 as i64), Value::I64(0 as i64)]); - + let result = instance.call( + "no_dce.i64.rem_s", + &[Value::I64(1 as i64), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c10_l36_assert_trap() { let mut instance = create_module_2(); - let result = c10_l36_action_invoke(&mut*instance); + let result = c10_l36_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 37 fn c11_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c11_l37_action_invoke"); - let result = instance.call("no_dce.i64.rem_u", &[Value::I64(1 as i64), Value::I64(0 as i64)]); - + let result = instance.call( + "no_dce.i64.rem_u", + &[Value::I64(1 as i64), Value::I64(0 as i64)], + ); + result.map(|_| ()) } #[test] fn c11_l37_assert_trap() { let mut instance = create_module_2(); - let result = c11_l37_action_invoke(&mut*instance); + let result = c11_l37_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -309,8 +344,11 @@ fn create_module_3() -> Box { (export \"no_dce.i64.trunc_u_f64\" (func 7))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_3(instance: &mut Instance) { @@ -321,120 +359,144 @@ fn start_module_3(instance: &mut Instance) { // Line 50 fn c13_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c13_l50_action_invoke"); - let result = instance.call("no_dce.i32.trunc_s_f32", &[Value::F32(f32::from_bits(2143289344))]); - + let result = instance.call( + "no_dce.i32.trunc_s_f32", + &[Value::F32(f32::from_bits(2143289344))], + ); + result.map(|_| ()) } #[test] fn c13_l50_assert_trap() { let mut instance = create_module_3(); - let result = c13_l50_action_invoke(&mut*instance); + let result = c13_l50_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 51 fn c14_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c14_l51_action_invoke"); - let result = instance.call("no_dce.i32.trunc_u_f32", &[Value::F32(f32::from_bits(2143289344))]); - + let result = instance.call( + "no_dce.i32.trunc_u_f32", + &[Value::F32(f32::from_bits(2143289344))], + ); + result.map(|_| ()) } #[test] fn c14_l51_assert_trap() { let mut instance = create_module_3(); - let result = c14_l51_action_invoke(&mut*instance); + let result = c14_l51_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 52 fn c15_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c15_l52_action_invoke"); - let result = instance.call("no_dce.i32.trunc_s_f64", &[Value::F64(f64::from_bits(9221120237041090560))]); - + let result = instance.call( + "no_dce.i32.trunc_s_f64", + &[Value::F64(f64::from_bits(9221120237041090560))], + ); + result.map(|_| ()) } #[test] fn c15_l52_assert_trap() { let mut instance = create_module_3(); - let result = c15_l52_action_invoke(&mut*instance); + let result = c15_l52_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 53 fn c16_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c16_l53_action_invoke"); - let result = instance.call("no_dce.i32.trunc_u_f64", &[Value::F64(f64::from_bits(9221120237041090560))]); - + let result = instance.call( + "no_dce.i32.trunc_u_f64", + &[Value::F64(f64::from_bits(9221120237041090560))], + ); + result.map(|_| ()) } #[test] fn c16_l53_assert_trap() { let mut instance = create_module_3(); - let result = c16_l53_action_invoke(&mut*instance); + let result = c16_l53_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 54 fn c17_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c17_l54_action_invoke"); - let result = instance.call("no_dce.i64.trunc_s_f32", &[Value::F32(f32::from_bits(2143289344))]); - + let result = instance.call( + "no_dce.i64.trunc_s_f32", + &[Value::F32(f32::from_bits(2143289344))], + ); + result.map(|_| ()) } #[test] fn c17_l54_assert_trap() { let mut instance = create_module_3(); - let result = c17_l54_action_invoke(&mut*instance); + let result = c17_l54_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 55 fn c18_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c18_l55_action_invoke"); - let result = instance.call("no_dce.i64.trunc_u_f32", &[Value::F32(f32::from_bits(2143289344))]); - + let result = instance.call( + "no_dce.i64.trunc_u_f32", + &[Value::F32(f32::from_bits(2143289344))], + ); + result.map(|_| ()) } #[test] fn c18_l55_assert_trap() { let mut instance = create_module_3(); - let result = c18_l55_action_invoke(&mut*instance); + let result = c18_l55_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 56 fn c19_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c19_l56_action_invoke"); - let result = instance.call("no_dce.i64.trunc_s_f64", &[Value::F64(f64::from_bits(9221120237041090560))]); - + let result = instance.call( + "no_dce.i64.trunc_s_f64", + &[Value::F64(f64::from_bits(9221120237041090560))], + ); + result.map(|_| ()) } #[test] fn c19_l56_assert_trap() { let mut instance = create_module_3(); - let result = c19_l56_action_invoke(&mut*instance); + let result = c19_l56_action_invoke(&mut *instance); assert!(result.is_err()); } // Line 57 fn c20_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c20_l57_action_invoke"); - let result = instance.call("no_dce.i64.trunc_u_f64", &[Value::F64(f64::from_bits(9221120237041090560))]); - + let result = instance.call( + "no_dce.i64.trunc_u_f64", + &[Value::F64(f64::from_bits(9221120237041090560))], + ); + result.map(|_| ()) } #[test] fn c20_l57_assert_trap() { let mut instance = create_module_3(); - let result = c20_l57_action_invoke(&mut*instance); + let result = c20_l57_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -522,8 +584,11 @@ fn create_module_4() -> Box { (export \"no_dce.f64.load\" (func 13))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_4(instance: &mut Instance) { @@ -535,14 +600,14 @@ fn start_module_4(instance: &mut Instance) { fn c22_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c22_l78_action_invoke"); let result = instance.call("no_dce.i32.load", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c22_l78_assert_trap() { let mut instance = create_module_4(); - let result = c22_l78_action_invoke(&mut*instance); + let result = c22_l78_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -550,14 +615,14 @@ fn c22_l78_assert_trap() { fn c23_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c23_l79_action_invoke"); let result = instance.call("no_dce.i32.load16_s", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c23_l79_assert_trap() { let mut instance = create_module_4(); - let result = c23_l79_action_invoke(&mut*instance); + let result = c23_l79_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -565,14 +630,14 @@ fn c23_l79_assert_trap() { fn c24_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c24_l80_action_invoke"); let result = instance.call("no_dce.i32.load16_u", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c24_l80_assert_trap() { let mut instance = create_module_4(); - let result = c24_l80_action_invoke(&mut*instance); + let result = c24_l80_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -580,14 +645,14 @@ fn c24_l80_assert_trap() { fn c25_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c25_l81_action_invoke"); let result = instance.call("no_dce.i32.load8_s", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c25_l81_assert_trap() { let mut instance = create_module_4(); - let result = c25_l81_action_invoke(&mut*instance); + let result = c25_l81_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -595,14 +660,14 @@ fn c25_l81_assert_trap() { fn c26_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c26_l82_action_invoke"); let result = instance.call("no_dce.i32.load8_u", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c26_l82_assert_trap() { let mut instance = create_module_4(); - let result = c26_l82_action_invoke(&mut*instance); + let result = c26_l82_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -610,14 +675,14 @@ fn c26_l82_assert_trap() { fn c27_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c27_l83_action_invoke"); let result = instance.call("no_dce.i64.load", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c27_l83_assert_trap() { let mut instance = create_module_4(); - let result = c27_l83_action_invoke(&mut*instance); + let result = c27_l83_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -625,14 +690,14 @@ fn c27_l83_assert_trap() { fn c28_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c28_l84_action_invoke"); let result = instance.call("no_dce.i64.load32_s", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c28_l84_assert_trap() { let mut instance = create_module_4(); - let result = c28_l84_action_invoke(&mut*instance); + let result = c28_l84_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -640,14 +705,14 @@ fn c28_l84_assert_trap() { fn c29_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c29_l85_action_invoke"); let result = instance.call("no_dce.i64.load32_u", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c29_l85_assert_trap() { let mut instance = create_module_4(); - let result = c29_l85_action_invoke(&mut*instance); + let result = c29_l85_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -655,14 +720,14 @@ fn c29_l85_assert_trap() { fn c30_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c30_l86_action_invoke"); let result = instance.call("no_dce.i64.load16_s", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c30_l86_assert_trap() { let mut instance = create_module_4(); - let result = c30_l86_action_invoke(&mut*instance); + let result = c30_l86_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -670,14 +735,14 @@ fn c30_l86_assert_trap() { fn c31_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c31_l87_action_invoke"); let result = instance.call("no_dce.i64.load16_u", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c31_l87_assert_trap() { let mut instance = create_module_4(); - let result = c31_l87_action_invoke(&mut*instance); + let result = c31_l87_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -685,14 +750,14 @@ fn c31_l87_assert_trap() { fn c32_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c32_l88_action_invoke"); let result = instance.call("no_dce.i64.load8_s", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c32_l88_assert_trap() { let mut instance = create_module_4(); - let result = c32_l88_action_invoke(&mut*instance); + let result = c32_l88_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -700,14 +765,14 @@ fn c32_l88_assert_trap() { fn c33_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c33_l89_action_invoke"); let result = instance.call("no_dce.i64.load8_u", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c33_l89_assert_trap() { let mut instance = create_module_4(); - let result = c33_l89_action_invoke(&mut*instance); + let result = c33_l89_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -715,14 +780,14 @@ fn c33_l89_assert_trap() { fn c34_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c34_l90_action_invoke"); let result = instance.call("no_dce.f32.load", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c34_l90_assert_trap() { let mut instance = create_module_4(); - let result = c34_l90_action_invoke(&mut*instance); + let result = c34_l90_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -730,14 +795,14 @@ fn c34_l90_assert_trap() { fn c35_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c35_l91_action_invoke"); let result = instance.call("no_dce.f64.load", &[Value::I32(65536 as i32)]); - + result.map(|_| ()) } #[test] fn c35_l91_assert_trap() { let mut instance = create_module_4(); - let result = c35_l91_action_invoke(&mut*instance); + let result = c35_l91_action_invoke(&mut *instance); assert!(result.is_err()); } diff --git a/lib/runtime/tests/spectests/typecheck.rs b/lib/runtime/tests/spectests/typecheck.rs index 77314b995..c139aef85 100644 --- a/lib/runtime/tests/spectests/typecheck.rs +++ b/lib/runtime/tests/spectests/typecheck.rs @@ -5,23 +5,21 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 4 #[test] fn c0_l4_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 69, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 69, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -29,7 +27,10 @@ fn c0_l4_assert_invalid() { // Line 10 #[test] fn c1_l10_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 0, 2, 64, 69, 26, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 0, 2, 64, + 69, 26, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -37,7 +38,10 @@ fn c1_l10_assert_invalid() { // Line 17 #[test] fn c2_l17_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 0, 3, 64, 69, 26, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 0, 3, 64, + 69, 26, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -45,7 +49,10 @@ fn c2_l17_assert_invalid() { // Line 24 #[test] fn c3_l24_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 65, 0, 4, 64, 69, 26, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 65, 0, + 4, 64, 69, 26, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -53,7 +60,10 @@ fn c3_l24_assert_invalid() { // Line 31 #[test] fn c4_l31_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, 65, 0, 4, 127, 65, 0, 5, 69, 11, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, 65, 0, + 4, 127, 65, 0, 5, 69, 11, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -61,7 +71,9 @@ fn c4_l31_assert_invalid() { // Line 39 #[test] fn c5_l39_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 106, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 106, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -69,7 +81,10 @@ fn c5_l39_assert_invalid() { // Line 45 #[test] fn c6_l45_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 8, 1, 6, 0, 65, 0, 106, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 8, 1, 6, 0, 65, 0, 106, 26, + 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -77,7 +92,10 @@ fn c6_l45_assert_invalid() { // Line 51 #[test] fn c7_l51_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 65, 0, 2, 64, 106, 26, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 65, 0, + 2, 64, 106, 26, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -85,7 +103,10 @@ fn c7_l51_assert_invalid() { // Line 58 #[test] fn c8_l58_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 2, 64, 65, 0, 106, 26, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 2, 64, + 65, 0, 106, 26, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -93,7 +114,10 @@ fn c8_l58_assert_invalid() { // Line 65 #[test] fn c9_l65_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 65, 0, 3, 64, 106, 26, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 65, 0, + 3, 64, 106, 26, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -101,7 +125,10 @@ fn c9_l65_assert_invalid() { // Line 72 #[test] fn c10_l72_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 3, 64, 65, 0, 106, 26, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 3, 64, + 65, 0, 106, 26, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -109,7 +136,10 @@ fn c10_l72_assert_invalid() { // Line 79 #[test] fn c11_l79_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 65, 0, 65, 0, 65, 0, 106, 4, 64, 26, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 65, 0, 65, 0, + 65, 0, 106, 4, 64, 26, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -117,7 +147,10 @@ fn c11_l79_assert_invalid() { // Line 86 #[test] fn c12_l86_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, 65, 0, 65, 0, 4, 64, 106, 5, 26, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, 65, 0, + 65, 0, 4, 64, 106, 5, 26, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -125,7 +158,10 @@ fn c12_l86_assert_invalid() { // Line 93 #[test] fn c13_l93_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 21, 1, 19, 0, 65, 0, 65, 0, 65, 0, 4, 127, 65, 0, 5, 106, 65, 0, 11, 26, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 21, 1, 19, 0, 65, 0, 65, 0, + 65, 0, 4, 127, 65, 0, 5, 106, 65, 0, 11, 26, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -133,7 +169,10 @@ fn c13_l93_assert_invalid() { // Line 101 #[test] fn c14_l101_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, 65, 0, 4, 127, 65, 0, 5, 106, 11, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, 65, 0, + 4, 127, 65, 0, 5, 106, 11, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -141,7 +180,9 @@ fn c14_l101_assert_invalid() { // Line 110 #[test] fn c15_l110_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 4, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 4, 64, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -149,7 +190,10 @@ fn c15_l110_assert_invalid() { // Line 116 #[test] fn c16_l116_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 2, 64, 4, 64, 11, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 2, 64, + 4, 64, 11, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -157,7 +201,10 @@ fn c16_l116_assert_invalid() { // Line 123 #[test] fn c17_l123_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 3, 64, 4, 64, 11, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 3, 64, + 4, 64, 11, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -165,7 +212,10 @@ fn c17_l123_assert_invalid() { // Line 130 #[test] fn c18_l130_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 0, 65, 0, 4, 64, 4, 64, 11, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 0, 65, 0, + 4, 64, 4, 64, 11, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -173,7 +223,10 @@ fn c18_l130_assert_invalid() { // Line 137 #[test] fn c19_l137_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 20, 1, 18, 0, 65, 0, 65, 0, 4, 127, 65, 0, 5, 4, 64, 11, 65, 0, 11, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 20, 1, 18, 0, 65, 0, 65, 0, + 4, 127, 65, 0, 5, 4, 64, 11, 65, 0, 11, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -181,7 +234,10 @@ fn c19_l137_assert_invalid() { // Line 146 #[test] fn c20_l146_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 12, 0, 11, 69, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 12, 0, + 11, 69, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -189,7 +245,10 @@ fn c20_l146_assert_invalid() { // Line 153 #[test] fn c21_l153_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 2, 127, 12, 0, 11, 69, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 2, + 127, 12, 0, 11, 69, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -197,7 +256,10 @@ fn c21_l153_assert_invalid() { // Line 161 #[test] fn c22_l161_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 64, 65, 0, 65, 0, 4, 127, 12, 0, 11, 11, 69, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 64, 65, 0, + 65, 0, 4, 127, 12, 0, 11, 11, 69, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -205,7 +267,10 @@ fn c22_l161_assert_invalid() { // Line 171 #[test] fn c23_l171_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 64, 65, 0, 65, 0, 4, 127, 65, 0, 5, 12, 0, 11, 11, 69, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 64, 65, 0, + 65, 0, 4, 127, 65, 0, 5, 12, 0, 11, 11, 69, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -213,7 +278,9 @@ fn c23_l171_assert_invalid() { // Line 182 #[test] fn c24_l182_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 15, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 15, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -221,7 +288,10 @@ fn c24_l182_assert_invalid() { // Line 188 #[test] fn c25_l188_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 2, 64, 15, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 2, + 64, 15, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -229,7 +299,10 @@ fn c25_l188_assert_invalid() { // Line 195 #[test] fn c26_l195_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 3, 64, 15, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 3, + 64, 15, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -237,7 +310,10 @@ fn c26_l195_assert_invalid() { // Line 202 #[test] fn c27_l202_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 65, 0, 4, 64, 15, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, + 65, 0, 4, 64, 15, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -245,7 +321,10 @@ fn c27_l202_assert_invalid() { // Line 209 #[test] fn c28_l209_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, 65, 0, 4, 127, 65, 0, 5, 15, 11, 26, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, + 65, 0, 4, 127, 65, 0, 5, 15, 11, 26, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -253,7 +332,10 @@ fn c28_l209_assert_invalid() { // Line 219 #[test] fn c29_l219_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 4, 64, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 67, 0, 0, 0, + 0, 4, 64, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -261,7 +343,10 @@ fn c29_l219_assert_invalid() { // Line 222 #[test] fn c30_l222_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 64, 67, 0, 0, 0, 0, 13, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 64, 67, 0, + 0, 0, 0, 13, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -269,7 +354,10 @@ fn c30_l222_assert_invalid() { // Line 226 #[test] fn c31_l226_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 0, 0, 14, 0, 0, 11, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, + 0, 0, 0, 14, 0, 0, 11, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -277,7 +365,10 @@ fn c31_l226_assert_invalid() { // Line 230 #[test] fn c32_l230_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 3, 2, 0, 1, 10, 14, 2, 2, 0, 11, 9, 0, 67, 0, 0, 0, 0, 16, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 3, 2, 0, 1, 10, 14, 2, 2, + 0, 11, 9, 0, 67, 0, 0, 0, 0, 16, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -285,7 +376,10 @@ fn c32_l230_assert_invalid() { // Line 232 #[test] fn c33_l232_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 3, 2, 0, 1, 4, 4, 1, 112, 0, 0, 10, 17, 2, 2, 0, 11, 12, 0, 65, 0, 67, 0, 0, 0, 0, 17, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 3, 2, 0, 1, 4, 4, 1, 112, + 0, 0, 10, 17, 2, 2, 0, 11, 12, 0, 65, 0, 67, 0, 0, 0, 0, 17, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -293,7 +387,10 @@ fn c33_l232_assert_invalid() { // Line 242 #[test] fn c34_l242_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 4, 4, 1, 112, 0, 0, 10, 15, 2, 2, 0, 11, 10, 0, 67, 0, 0, 0, 0, 17, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 4, 4, 1, 112, 0, 0, 10, 15, + 2, 2, 0, 11, 10, 0, 67, 0, 0, 0, 0, 17, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -301,7 +398,10 @@ fn c34_l242_assert_invalid() { // Line 250 #[test] fn c35_l250_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 67, 0, 0, 0, 0, 15, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 67, 0, 0, + 0, 0, 15, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -309,7 +409,10 @@ fn c35_l250_assert_invalid() { // Line 253 #[test] fn c36_l253_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, 67, 0, 0, 0, 0, 33, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, 67, + 0, 0, 0, 0, 33, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -317,7 +420,10 @@ fn c36_l253_assert_invalid() { // Line 256 #[test] fn c37_l256_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 40, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, + 0, 67, 0, 0, 0, 0, 40, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -325,7 +431,10 @@ fn c37_l256_assert_invalid() { // Line 257 #[test] fn c38_l257_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 44, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, + 0, 67, 0, 0, 0, 0, 44, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -333,7 +442,10 @@ fn c38_l257_assert_invalid() { // Line 258 #[test] fn c39_l258_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 45, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, + 0, 67, 0, 0, 0, 0, 45, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -341,7 +453,10 @@ fn c39_l258_assert_invalid() { // Line 259 #[test] fn c40_l259_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 46, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, + 0, 67, 0, 0, 0, 0, 46, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -349,7 +464,10 @@ fn c40_l259_assert_invalid() { // Line 260 #[test] fn c41_l260_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 47, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, + 0, 67, 0, 0, 0, 0, 47, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -357,7 +475,10 @@ fn c41_l260_assert_invalid() { // Line 261 #[test] fn c42_l261_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 41, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, + 0, 67, 0, 0, 0, 0, 41, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -365,7 +486,10 @@ fn c42_l261_assert_invalid() { // Line 262 #[test] fn c43_l262_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 48, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, + 0, 67, 0, 0, 0, 0, 48, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -373,7 +497,10 @@ fn c43_l262_assert_invalid() { // Line 263 #[test] fn c44_l263_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 49, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, + 0, 67, 0, 0, 0, 0, 49, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -381,7 +508,10 @@ fn c44_l263_assert_invalid() { // Line 264 #[test] fn c45_l264_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 50, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, + 0, 67, 0, 0, 0, 0, 50, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -389,7 +519,10 @@ fn c45_l264_assert_invalid() { // Line 265 #[test] fn c46_l265_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 51, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, + 0, 67, 0, 0, 0, 0, 51, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -397,7 +530,10 @@ fn c46_l265_assert_invalid() { // Line 266 #[test] fn c47_l266_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 52, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, + 0, 67, 0, 0, 0, 0, 52, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -405,7 +541,10 @@ fn c47_l266_assert_invalid() { // Line 267 #[test] fn c48_l267_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 53, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, + 0, 67, 0, 0, 0, 0, 53, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -413,7 +552,10 @@ fn c48_l267_assert_invalid() { // Line 268 #[test] fn c49_l268_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 42, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, + 0, 67, 0, 0, 0, 0, 42, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -421,7 +563,10 @@ fn c49_l268_assert_invalid() { // Line 269 #[test] fn c50_l269_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 43, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, + 0, 67, 0, 0, 0, 0, 43, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -429,7 +574,10 @@ fn c50_l269_assert_invalid() { // Line 272 #[test] fn c51_l272_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 65, 0, 54, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, + 0, 67, 0, 0, 0, 0, 65, 0, 54, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -437,7 +585,10 @@ fn c51_l272_assert_invalid() { // Line 273 #[test] fn c52_l273_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 65, 0, 58, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, + 0, 67, 0, 0, 0, 0, 65, 0, 58, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -445,7 +596,10 @@ fn c52_l273_assert_invalid() { // Line 274 #[test] fn c53_l274_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 65, 0, 59, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, + 0, 67, 0, 0, 0, 0, 65, 0, 59, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -453,7 +607,10 @@ fn c53_l274_assert_invalid() { // Line 275 #[test] fn c54_l275_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 65, 0, 55, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, + 0, 67, 0, 0, 0, 0, 65, 0, 55, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -461,7 +618,10 @@ fn c54_l275_assert_invalid() { // Line 276 #[test] fn c55_l276_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 66, 0, 60, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, + 0, 67, 0, 0, 0, 0, 66, 0, 60, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -469,7 +629,10 @@ fn c55_l276_assert_invalid() { // Line 277 #[test] fn c56_l277_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 66, 0, 61, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, + 0, 67, 0, 0, 0, 0, 66, 0, 61, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -477,7 +640,10 @@ fn c56_l277_assert_invalid() { // Line 278 #[test] fn c57_l278_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 66, 0, 62, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, + 0, 67, 0, 0, 0, 0, 66, 0, 62, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -485,7 +651,10 @@ fn c57_l278_assert_invalid() { // Line 279 #[test] fn c58_l279_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 17, 1, 15, 0, 67, 0, 0, 0, 0, 67, 0, 0, 0, 0, 56, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 17, 1, 15, + 0, 67, 0, 0, 0, 0, 67, 0, 0, 0, 0, 56, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -493,7 +662,10 @@ fn c58_l279_assert_invalid() { // Line 280 #[test] fn c59_l280_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 21, 1, 19, 0, 67, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 57, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 21, 1, 19, + 0, 67, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 57, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -501,7 +673,10 @@ fn c59_l280_assert_invalid() { // Line 283 #[test] fn c60_l283_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 65, 0, 67, 0, 0, 0, 0, 54, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, + 0, 65, 0, 67, 0, 0, 0, 0, 54, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -509,7 +684,10 @@ fn c60_l283_assert_invalid() { // Line 284 #[test] fn c61_l284_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 65, 0, 67, 0, 0, 0, 0, 58, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, + 0, 65, 0, 67, 0, 0, 0, 0, 58, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -517,7 +695,10 @@ fn c61_l284_assert_invalid() { // Line 285 #[test] fn c62_l285_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 65, 0, 67, 0, 0, 0, 0, 59, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, + 0, 65, 0, 67, 0, 0, 0, 0, 59, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -525,7 +706,10 @@ fn c62_l285_assert_invalid() { // Line 286 #[test] fn c63_l286_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 65, 0, 67, 0, 0, 0, 0, 55, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, + 0, 65, 0, 67, 0, 0, 0, 0, 55, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -533,7 +717,10 @@ fn c63_l286_assert_invalid() { // Line 287 #[test] fn c64_l287_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 18, 1, 16, 0, 65, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 60, 0, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 18, 1, 16, + 0, 65, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 60, 0, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -541,7 +728,10 @@ fn c64_l287_assert_invalid() { // Line 288 #[test] fn c65_l288_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 18, 1, 16, 0, 65, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 61, 1, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 18, 1, 16, + 0, 65, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 61, 1, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -549,7 +739,10 @@ fn c65_l288_assert_invalid() { // Line 289 #[test] fn c66_l289_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 18, 1, 16, 0, 65, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 62, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 18, 1, 16, + 0, 65, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 62, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -557,7 +750,10 @@ fn c66_l289_assert_invalid() { // Line 290 #[test] fn c67_l290_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 65, 0, 56, 2, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, + 65, 0, 65, 0, 56, 2, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -565,7 +761,10 @@ fn c67_l290_assert_invalid() { // Line 291 #[test] fn c68_l291_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 66, 0, 57, 3, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, + 65, 0, 66, 0, 57, 3, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -573,7 +772,10 @@ fn c68_l291_assert_invalid() { // Line 294 #[test] fn c69_l294_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 106, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 106, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -581,7 +783,10 @@ fn c69_l294_assert_invalid() { // Line 295 #[test] fn c70_l295_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 113, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 113, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -589,7 +794,10 @@ fn c70_l295_assert_invalid() { // Line 296 #[test] fn c71_l296_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 109, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 109, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -597,7 +805,10 @@ fn c71_l296_assert_invalid() { // Line 297 #[test] fn c72_l297_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 110, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 110, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -605,7 +816,10 @@ fn c72_l297_assert_invalid() { // Line 298 #[test] fn c73_l298_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 108, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 108, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -613,7 +827,10 @@ fn c73_l298_assert_invalid() { // Line 299 #[test] fn c74_l299_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 114, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 114, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -621,7 +838,10 @@ fn c74_l299_assert_invalid() { // Line 300 #[test] fn c75_l300_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 111, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 111, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -629,7 +849,10 @@ fn c75_l300_assert_invalid() { // Line 301 #[test] fn c76_l301_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 112, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 112, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -637,7 +860,10 @@ fn c76_l301_assert_invalid() { // Line 302 #[test] fn c77_l302_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 119, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 119, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -645,7 +871,10 @@ fn c77_l302_assert_invalid() { // Line 303 #[test] fn c78_l303_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 120, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 120, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -653,7 +882,10 @@ fn c78_l303_assert_invalid() { // Line 304 #[test] fn c79_l304_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 116, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 116, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -661,7 +893,10 @@ fn c79_l304_assert_invalid() { // Line 305 #[test] fn c80_l305_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 117, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 117, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -669,7 +904,10 @@ fn c80_l305_assert_invalid() { // Line 306 #[test] fn c81_l306_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 118, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 118, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -677,7 +915,10 @@ fn c81_l306_assert_invalid() { // Line 307 #[test] fn c82_l307_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 107, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 107, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -685,7 +926,10 @@ fn c82_l307_assert_invalid() { // Line 308 #[test] fn c83_l308_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 115, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 115, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -693,7 +937,10 @@ fn c83_l308_assert_invalid() { // Line 309 #[test] fn c84_l309_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 124, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 124, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -701,7 +948,10 @@ fn c84_l309_assert_invalid() { // Line 310 #[test] fn c85_l310_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 131, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 131, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -709,7 +959,10 @@ fn c85_l310_assert_invalid() { // Line 311 #[test] fn c86_l311_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 127, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 127, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -717,7 +970,10 @@ fn c86_l311_assert_invalid() { // Line 312 #[test] fn c87_l312_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 128, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 128, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -725,7 +981,10 @@ fn c87_l312_assert_invalid() { // Line 313 #[test] fn c88_l313_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 126, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 126, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -733,7 +992,10 @@ fn c88_l313_assert_invalid() { // Line 314 #[test] fn c89_l314_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 132, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 132, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -741,7 +1003,10 @@ fn c89_l314_assert_invalid() { // Line 315 #[test] fn c90_l315_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 129, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 129, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -749,7 +1014,10 @@ fn c90_l315_assert_invalid() { // Line 316 #[test] fn c91_l316_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 130, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 130, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -757,7 +1025,10 @@ fn c91_l316_assert_invalid() { // Line 317 #[test] fn c92_l317_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 137, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 137, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -765,7 +1036,10 @@ fn c92_l317_assert_invalid() { // Line 318 #[test] fn c93_l318_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 138, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 138, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -773,7 +1047,10 @@ fn c93_l318_assert_invalid() { // Line 319 #[test] fn c94_l319_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 134, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 134, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -781,7 +1058,10 @@ fn c94_l319_assert_invalid() { // Line 320 #[test] fn c95_l320_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 135, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 135, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -789,7 +1069,10 @@ fn c95_l320_assert_invalid() { // Line 321 #[test] fn c96_l321_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 136, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 136, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -797,7 +1080,10 @@ fn c96_l321_assert_invalid() { // Line 322 #[test] fn c97_l322_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 125, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 125, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -805,7 +1091,10 @@ fn c97_l322_assert_invalid() { // Line 323 #[test] fn c98_l323_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 133, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 133, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -813,7 +1102,10 @@ fn c98_l323_assert_invalid() { // Line 324 #[test] fn c99_l324_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 146, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 146, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -821,7 +1113,10 @@ fn c99_l324_assert_invalid() { // Line 325 #[test] fn c100_l325_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 152, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 152, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -829,7 +1124,10 @@ fn c100_l325_assert_invalid() { // Line 326 #[test] fn c101_l326_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 149, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 149, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -837,7 +1135,10 @@ fn c101_l326_assert_invalid() { // Line 327 #[test] fn c102_l327_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 151, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 151, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -845,7 +1146,10 @@ fn c102_l327_assert_invalid() { // Line 328 #[test] fn c103_l328_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 150, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 150, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -853,7 +1157,10 @@ fn c103_l328_assert_invalid() { // Line 329 #[test] fn c104_l329_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 148, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 148, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -861,7 +1168,10 @@ fn c104_l329_assert_invalid() { // Line 330 #[test] fn c105_l330_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 147, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 147, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -869,7 +1179,10 @@ fn c105_l330_assert_invalid() { // Line 331 #[test] fn c106_l331_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 160, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 160, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -877,7 +1190,10 @@ fn c106_l331_assert_invalid() { // Line 332 #[test] fn c107_l332_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 166, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 166, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -885,7 +1201,10 @@ fn c107_l332_assert_invalid() { // Line 333 #[test] fn c108_l333_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 163, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 163, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -893,7 +1212,10 @@ fn c108_l333_assert_invalid() { // Line 334 #[test] fn c109_l334_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 165, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 165, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -901,7 +1223,10 @@ fn c109_l334_assert_invalid() { // Line 335 #[test] fn c110_l335_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 164, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 164, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -909,7 +1234,10 @@ fn c110_l335_assert_invalid() { // Line 336 #[test] fn c111_l336_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 162, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 162, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -917,7 +1245,10 @@ fn c111_l336_assert_invalid() { // Line 337 #[test] fn c112_l337_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 161, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 161, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -925,7 +1256,9 @@ fn c112_l337_assert_invalid() { // Line 340 #[test] fn c113_l340_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 69, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 69, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -933,7 +1266,9 @@ fn c113_l340_assert_invalid() { // Line 341 #[test] fn c114_l341_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 103, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 103, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -941,7 +1276,9 @@ fn c114_l341_assert_invalid() { // Line 342 #[test] fn c115_l342_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 104, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 104, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -949,7 +1286,9 @@ fn c115_l342_assert_invalid() { // Line 343 #[test] fn c116_l343_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 105, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 105, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -957,7 +1296,9 @@ fn c116_l343_assert_invalid() { // Line 344 #[test] fn c117_l344_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 80, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 80, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -965,7 +1306,9 @@ fn c117_l344_assert_invalid() { // Line 345 #[test] fn c118_l345_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 121, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 121, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -973,7 +1316,9 @@ fn c118_l345_assert_invalid() { // Line 346 #[test] fn c119_l346_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 122, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 122, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -981,7 +1326,9 @@ fn c119_l346_assert_invalid() { // Line 347 #[test] fn c120_l347_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 123, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 123, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -989,7 +1336,9 @@ fn c120_l347_assert_invalid() { // Line 348 #[test] fn c121_l348_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 139, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 139, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -997,7 +1346,9 @@ fn c121_l348_assert_invalid() { // Line 349 #[test] fn c122_l349_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 141, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 141, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1005,7 +1356,9 @@ fn c122_l349_assert_invalid() { // Line 350 #[test] fn c123_l350_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 142, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 142, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1013,7 +1366,9 @@ fn c123_l350_assert_invalid() { // Line 351 #[test] fn c124_l351_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 144, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 144, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1021,7 +1376,9 @@ fn c124_l351_assert_invalid() { // Line 352 #[test] fn c125_l352_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 140, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 140, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1029,7 +1386,9 @@ fn c125_l352_assert_invalid() { // Line 353 #[test] fn c126_l353_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 145, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 145, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1037,7 +1396,9 @@ fn c126_l353_assert_invalid() { // Line 354 #[test] fn c127_l354_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 143, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 143, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1045,7 +1406,9 @@ fn c127_l354_assert_invalid() { // Line 355 #[test] fn c128_l355_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 153, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 153, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1053,7 +1416,9 @@ fn c128_l355_assert_invalid() { // Line 356 #[test] fn c129_l356_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 155, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 155, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1061,7 +1426,9 @@ fn c129_l356_assert_invalid() { // Line 357 #[test] fn c130_l357_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 156, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 156, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1069,7 +1436,9 @@ fn c130_l357_assert_invalid() { // Line 358 #[test] fn c131_l358_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 158, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 158, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1077,7 +1446,9 @@ fn c131_l358_assert_invalid() { // Line 359 #[test] fn c132_l359_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 154, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 154, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1085,7 +1456,9 @@ fn c132_l359_assert_invalid() { // Line 360 #[test] fn c133_l360_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 159, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 159, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1093,7 +1466,9 @@ fn c133_l360_assert_invalid() { // Line 361 #[test] fn c134_l361_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 157, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 157, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1101,7 +1476,10 @@ fn c134_l361_assert_invalid() { // Line 364 #[test] fn c135_l364_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 70, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 70, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1109,7 +1487,10 @@ fn c135_l364_assert_invalid() { // Line 365 #[test] fn c136_l365_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 78, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 78, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1117,7 +1498,10 @@ fn c136_l365_assert_invalid() { // Line 366 #[test] fn c137_l366_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 79, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 79, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1125,7 +1509,10 @@ fn c137_l366_assert_invalid() { // Line 367 #[test] fn c138_l367_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 74, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 74, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1133,7 +1520,10 @@ fn c138_l367_assert_invalid() { // Line 368 #[test] fn c139_l368_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 75, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 75, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1141,7 +1531,10 @@ fn c139_l368_assert_invalid() { // Line 369 #[test] fn c140_l369_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 76, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 76, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1149,7 +1542,10 @@ fn c140_l369_assert_invalid() { // Line 370 #[test] fn c141_l370_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 77, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 77, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1157,7 +1553,10 @@ fn c141_l370_assert_invalid() { // Line 371 #[test] fn c142_l371_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 72, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 72, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1165,7 +1564,10 @@ fn c142_l371_assert_invalid() { // Line 372 #[test] fn c143_l372_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 73, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 73, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1173,7 +1575,10 @@ fn c143_l372_assert_invalid() { // Line 373 #[test] fn c144_l373_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 71, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 71, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1181,7 +1586,10 @@ fn c144_l373_assert_invalid() { // Line 374 #[test] fn c145_l374_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 81, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 81, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1189,7 +1597,10 @@ fn c145_l374_assert_invalid() { // Line 375 #[test] fn c146_l375_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 89, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 89, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1197,7 +1608,10 @@ fn c146_l375_assert_invalid() { // Line 376 #[test] fn c147_l376_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 90, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 90, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1205,7 +1619,10 @@ fn c147_l376_assert_invalid() { // Line 377 #[test] fn c148_l377_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 85, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 85, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1213,7 +1630,10 @@ fn c148_l377_assert_invalid() { // Line 378 #[test] fn c149_l378_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 86, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 86, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1221,7 +1641,10 @@ fn c149_l378_assert_invalid() { // Line 379 #[test] fn c150_l379_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 87, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 87, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1229,7 +1652,10 @@ fn c150_l379_assert_invalid() { // Line 380 #[test] fn c151_l380_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 88, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 88, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1237,7 +1663,10 @@ fn c151_l380_assert_invalid() { // Line 381 #[test] fn c152_l381_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 83, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 83, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1245,7 +1674,10 @@ fn c152_l381_assert_invalid() { // Line 382 #[test] fn c153_l382_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 84, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 84, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1253,7 +1685,10 @@ fn c153_l382_assert_invalid() { // Line 383 #[test] fn c154_l383_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 82, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, + 0, 0, 0, 82, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1261,7 +1696,10 @@ fn c154_l383_assert_invalid() { // Line 384 #[test] fn c155_l384_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 91, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 91, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1269,7 +1707,10 @@ fn c155_l384_assert_invalid() { // Line 385 #[test] fn c156_l385_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 96, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 96, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1277,7 +1718,10 @@ fn c156_l385_assert_invalid() { // Line 386 #[test] fn c157_l386_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 94, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 94, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1285,7 +1729,10 @@ fn c157_l386_assert_invalid() { // Line 387 #[test] fn c158_l387_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 95, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 95, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1293,7 +1740,10 @@ fn c158_l387_assert_invalid() { // Line 388 #[test] fn c159_l388_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 93, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 93, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1301,7 +1751,10 @@ fn c159_l388_assert_invalid() { // Line 389 #[test] fn c160_l389_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 92, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 92, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1309,7 +1762,10 @@ fn c160_l389_assert_invalid() { // Line 390 #[test] fn c161_l390_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 97, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 97, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1317,7 +1773,10 @@ fn c161_l390_assert_invalid() { // Line 391 #[test] fn c162_l391_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 102, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 102, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1325,7 +1784,10 @@ fn c162_l391_assert_invalid() { // Line 392 #[test] fn c163_l392_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 100, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 100, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1333,7 +1795,10 @@ fn c163_l392_assert_invalid() { // Line 393 #[test] fn c164_l393_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 101, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 101, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1341,7 +1806,10 @@ fn c164_l393_assert_invalid() { // Line 394 #[test] fn c165_l394_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 99, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 99, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1349,7 +1817,10 @@ fn c165_l394_assert_invalid() { // Line 395 #[test] fn c166_l395_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 98, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, + 0, 0, 0, 98, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1357,7 +1828,10 @@ fn c166_l395_assert_invalid() { // Line 398 #[test] fn c167_l398_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 67, 0, 0, 0, 0, 167, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 67, 0, 0, 0, + 0, 167, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1365,7 +1839,9 @@ fn c167_l398_assert_invalid() { // Line 399 #[test] fn c168_l399_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 168, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 168, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1373,7 +1849,9 @@ fn c168_l399_assert_invalid() { // Line 400 #[test] fn c169_l400_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 169, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 169, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1381,7 +1859,9 @@ fn c169_l400_assert_invalid() { // Line 401 #[test] fn c170_l401_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 170, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 170, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1389,7 +1869,9 @@ fn c170_l401_assert_invalid() { // Line 402 #[test] fn c171_l402_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 171, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 171, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1397,7 +1879,9 @@ fn c171_l402_assert_invalid() { // Line 403 #[test] fn c172_l403_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 188, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 188, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1405,7 +1889,10 @@ fn c172_l403_assert_invalid() { // Line 404 #[test] fn c173_l404_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 67, 0, 0, 0, 0, 172, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 67, 0, 0, 0, + 0, 172, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1413,7 +1900,10 @@ fn c173_l404_assert_invalid() { // Line 405 #[test] fn c174_l405_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 67, 0, 0, 0, 0, 173, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 67, 0, 0, 0, + 0, 173, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1421,7 +1911,9 @@ fn c174_l405_assert_invalid() { // Line 406 #[test] fn c175_l406_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 174, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 174, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1429,7 +1921,9 @@ fn c175_l406_assert_invalid() { // Line 407 #[test] fn c176_l407_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 175, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 175, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1437,7 +1931,9 @@ fn c176_l407_assert_invalid() { // Line 408 #[test] fn c177_l408_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 176, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 176, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1445,7 +1941,9 @@ fn c177_l408_assert_invalid() { // Line 409 #[test] fn c178_l409_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 177, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 177, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1453,7 +1951,9 @@ fn c178_l409_assert_invalid() { // Line 410 #[test] fn c179_l410_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 189, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 189, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1461,7 +1961,9 @@ fn c179_l410_assert_invalid() { // Line 411 #[test] fn c180_l411_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 178, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 178, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1469,7 +1971,9 @@ fn c180_l411_assert_invalid() { // Line 412 #[test] fn c181_l412_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 179, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 179, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1477,7 +1981,9 @@ fn c181_l412_assert_invalid() { // Line 413 #[test] fn c182_l413_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 180, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 180, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1485,7 +1991,9 @@ fn c182_l413_assert_invalid() { // Line 414 #[test] fn c183_l414_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 181, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 181, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1493,7 +2001,9 @@ fn c183_l414_assert_invalid() { // Line 415 #[test] fn c184_l415_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 182, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 182, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1501,7 +2011,9 @@ fn c184_l415_assert_invalid() { // Line 416 #[test] fn c185_l416_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 190, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 190, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1509,7 +2021,9 @@ fn c185_l416_assert_invalid() { // Line 417 #[test] fn c186_l417_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 183, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 183, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1517,7 +2031,9 @@ fn c186_l417_assert_invalid() { // Line 418 #[test] fn c187_l418_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 184, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 184, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1525,7 +2041,9 @@ fn c187_l418_assert_invalid() { // Line 419 #[test] fn c188_l419_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 185, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 185, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1533,7 +2051,9 @@ fn c188_l419_assert_invalid() { // Line 420 #[test] fn c189_l420_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 186, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 186, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1541,7 +2061,9 @@ fn c189_l420_assert_invalid() { // Line 421 #[test] fn c190_l421_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 187, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 187, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1549,7 +2071,9 @@ fn c190_l421_assert_invalid() { // Line 422 #[test] fn c191_l422_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 191, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 191, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } @@ -1557,7 +2081,10 @@ fn c191_l422_assert_invalid() { // Line 425 #[test] fn c192_l425_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 67, 0, 0, 0, 0, 64, 0, 11]; + let wasm_binary = [ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, + 67, 0, 0, 0, 0, 64, 0, 11, + ]; let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), "WASM should not compile as is invalid"); } diff --git a/lib/runtime/tests/spectests/types.rs b/lib/runtime/tests/spectests/types.rs index 380c393f1..ddc78be35 100644 --- a/lib/runtime/tests/spectests/types.rs +++ b/lib/runtime/tests/spectests/types.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -37,8 +33,11 @@ fn create_module_1() -> Box { (type (;13;) (func (param f32 f64 i32)))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -49,17 +48,29 @@ fn start_module_1(instance: &mut Instance) { // Line 44 #[test] fn c1_l44_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, + 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 48 #[test] fn c2_l48_assert_malformed() { - let wasm_binary = [40, 116, 121, 112, 101, 32, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 36, 120, 32, 105, 51, 50, 41, 41, 41]; + let wasm_binary = [ + 40, 116, 121, 112, 101, 32, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, + 32, 36, 120, 32, 105, 51, 50, 41, 41, 41, + ]; let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); - assert!(compilation.is_err(), "WASM should not compile as is malformed"); + assert!( + compilation.is_err(), + "WASM should not compile as is malformed" + ); } // Line 53 diff --git a/lib/runtime/tests/spectests/unwind.rs b/lib/runtime/tests/spectests/unwind.rs index 02f2b2cab..d7e5451b2 100644 --- a/lib/runtime/tests/spectests/unwind.rs +++ b/lib/runtime/tests/spectests/unwind.rs @@ -5,18 +5,14 @@ warnings, dead_code )] -use wabt::wat2wasm; use std::{f32, f64}; +use wabt::wat2wasm; -use wasmer_runtime::types::Value; -use wasmer_runtime::{Instance, module::Module}; use wasmer_clif_backend::CraneliftCompiler; +use wasmer_runtime::types::Value; +use wasmer_runtime::{module::Module, Instance}; -use crate::spectests::_common::{ - spectest_importobject, - NaNCheck, -}; - +use crate::spectests::_common::{generate_imports, NaNCheck}; // Line 3 fn create_module_1() -> Box { @@ -446,8 +442,11 @@ fn create_module_1() -> Box { (export \"loop-value-after-return\" (func 48))) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); - let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled"); - module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated") + let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()) + .expect("WASM can't be compiled"); + module + .instantiate(generate_imports()) + .expect("WASM can't be instantiated") } fn start_module_1(instance: &mut Instance) { @@ -459,14 +458,14 @@ fn start_module_1(instance: &mut Instance) { fn c1_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c1_l212_action_invoke"); let result = instance.call("func-unwind-by-unreachable", &[]); - + result.map(|_| ()) } #[test] fn c1_l212_assert_trap() { let mut instance = create_module_1(); - let result = c1_l212_action_invoke(&mut*instance); + let result = c1_l212_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -530,14 +529,14 @@ fn c8_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c9_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c9_l221_action_invoke"); let result = instance.call("block-unwind-by-unreachable", &[]); - + result.map(|_| ()) } #[test] fn c9_l221_assert_trap() { let mut instance = create_module_1(); - let result = c9_l221_action_invoke(&mut*instance); + let result = c9_l221_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -601,14 +600,14 @@ fn c16_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c17_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c17_l230_action_invoke"); let result = instance.call("block-nested-unwind-by-unreachable", &[]); - + result.map(|_| ()) } #[test] fn c17_l230_assert_trap() { let mut instance = create_module_1(); - let result = c17_l230_action_invoke(&mut*instance); + let result = c17_l230_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -672,14 +671,14 @@ fn c24_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c25_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c25_l239_action_invoke"); let result = instance.call("unary-after-unreachable", &[]); - + result.map(|_| ()) } #[test] fn c25_l239_assert_trap() { let mut instance = create_module_1(); - let result = c25_l239_action_invoke(&mut*instance); + let result = c25_l239_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -719,14 +718,14 @@ fn c29_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c30_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c30_l245_action_invoke"); let result = instance.call("binary-after-unreachable", &[]); - + result.map(|_| ()) } #[test] fn c30_l245_assert_trap() { let mut instance = create_module_1(); - let result = c30_l245_action_invoke(&mut*instance); + let result = c30_l245_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -766,14 +765,14 @@ fn c34_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c35_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c35_l251_action_invoke"); let result = instance.call("select-after-unreachable", &[]); - + result.map(|_| ()) } #[test] fn c35_l251_assert_trap() { let mut instance = create_module_1(); - let result = c35_l251_action_invoke(&mut*instance); + let result = c35_l251_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -813,14 +812,14 @@ fn c39_l255_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c40_l257_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c40_l257_action_invoke"); let result = instance.call("block-value-after-unreachable", &[]); - + result.map(|_| ()) } #[test] fn c40_l257_assert_trap() { let mut instance = create_module_1(); - let result = c40_l257_action_invoke(&mut*instance); + let result = c40_l257_action_invoke(&mut *instance); assert!(result.is_err()); } @@ -860,14 +859,14 @@ fn c44_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { fn c45_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { println!("Executing function {}", "c45_l263_action_invoke"); let result = instance.call("loop-value-after-unreachable", &[]); - + result.map(|_| ()) } #[test] fn c45_l263_assert_trap() { let mut instance = create_module_1(); - let result = c45_l263_action_invoke(&mut*instance); + let result = c45_l263_action_invoke(&mut *instance); assert!(result.is_err()); }