code002lover/Wasynth
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compartmentalize tests

Browse Source
This commit is contained in:
Rerumu 2022-06-12 19:55:42 -04:00
parent e9c48f6cec
commit 20b888bfa0
4 changed files with 537 additions and 389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

169
dev-test/tests/luajit_translate.rs Normal file
View File

@ -0,0 +1,169 @@
use std::{
io::{Result, Write},
path::PathBuf,
};
use wast::{
core::{Expression, Instruction},
token::{Float32, Float64},
AssertExpression, WastExecute, WastInvoke,
};
use target::{Target, TypedModule};
mod target;
static ASSERTION: &str = include_str!("assertion.lua");
struct LuaJIT;
impl LuaJIT {
fn write_expression(data: &Expression, w: &mut dyn Write) -> Result<()> {
let data = &data.instrs;
assert_eq!(data.len(), 1, "Only one instruction supported");
match &data[0] {
Instruction::I32Const(v) => write!(w, "{v}"),
Instruction::I64Const(v) => write!(w, "{v}LL"),
Instruction::F32Const(v) => write!(w, "{}", f32::from_bits(v.bits)),
Instruction::F64Const(v) => write!(w, "{}", f64::from_bits(v.bits)),
_ => panic!("Unsupported instruction"),
}
}
write_assert_number!(write_assert_maybe_f32, Float32, f32);
write_assert_number!(write_assert_maybe_f64, Float64, f64);
fn write_simple_expression(data: &AssertExpression, w: &mut dyn Write) -> Result<()> {
match data {
AssertExpression::I32(v) => write!(w, "{v}"),
AssertExpression::I64(v) => write!(w, "{v}LL"),
AssertExpression::F32(v) => Self::write_assert_maybe_f32(v, w),
AssertExpression::F64(v) => Self::write_assert_maybe_f64(v, w),
_ => panic!("Unsupported expression"),
}
}
fn write_call_of(handler: &str, data: &WastInvoke, w: &mut dyn Write) -> Result<()> {
let name = TypedModule::resolve_id(data.module);
let func = data.name;
write!(w, "{handler}(")?;
write!(w, r#"loaded["{name}"].func_list["{func}"]"#)?;
data.args.iter().try_for_each(|v| {
write!(w, ", ")?;
Self::write_expression(v, w)
})?;
write!(w, ")")
}
}
impl Target for LuaJIT {
fn executable() -> String {
std::env::var("LUAJIT_PATH").unwrap_or_else(|_| "luajit".to_string())
}
fn write_register(post: &str, pre: &str, w: &mut dyn Write) -> Result<()> {
writeln!(w, r#"linked["{post}"] = loaded["{pre}"]"#)
}
fn write_invoke(data: &WastInvoke, w: &mut dyn Write) -> Result<()> {
Self::write_call_of("raw_invoke", data, w)?;
writeln!(w)
}
fn write_assert_trap(data: &WastExecute, w: &mut dyn Write) -> Result<()> {
match data {
WastExecute::Invoke(data) => {
Self::write_call_of("assert_trap", data, w)?;
writeln!(w)
}
WastExecute::Get { module, global } => {
let name = TypedModule::resolve_id(*module);
write!(w, "assert_neq(")?;
write!(w, r#"loaded["{name}"].global_list["{global}"].value"#)?;
writeln!(w, ", nil)")
}
WastExecute::Wat(_) => panic!("Wat not supported"),
}
}
fn write_assert_return(
data: &WastExecute,
result: &[AssertExpression],
w: &mut dyn Write,
) -> Result<()> {
match data {
WastExecute::Invoke(data) => {
write!(w, "assert_return(")?;
write!(w, "{{")?;
Self::write_call_of("raw_invoke", data, w)?;
write!(w, "}}, {{")?;
for v in result {
Self::write_simple_expression(v, w)?;
write!(w, ", ")?;
}
writeln!(w, "}})")
}
WastExecute::Get { module, global } => {
let name = TypedModule::resolve_id(*module);
write!(w, "assert_eq(")?;
write!(w, r#"loaded["{name}"].global_list["{global}"].value"#)?;
write!(w, ", ")?;
Self::write_simple_expression(&result[0], w)?;
writeln!(w, ")")
}
WastExecute::Wat(_) => panic!("Wat not supported"),
}
}
fn write_assert_exhaustion(data: &WastInvoke, w: &mut dyn Write) -> Result<()> {
Self::write_call_of("assert_exhaustion", data, w)?;
writeln!(w)
}
fn write_runtime(w: &mut dyn Write) -> Result<()> {
let runtime = codegen_luajit::RUNTIME;
writeln!(w, "{ASSERTION}")?;
writeln!(w, "local rt = (function() {runtime} end)()")
}
fn write_module(typed: &TypedModule, w: &mut dyn Write) -> Result<()> {
write!(w, r#"loaded["{}"] = (function() "#, typed.name())?;
codegen_luajit::from_module_typed(typed.module(), typed.type_info(), w)?;
writeln!(w, "end)()(nil)")
}
}
static DO_NOT_RUN: [&str; 8] = [
"binary-leb128.wast",
"conversions.wast",
"float_exprs.wast",
"float_literals.wast",
"float_memory.wast",
"float_misc.wast",
"names.wast",
"skip-stack-guard-page.wast",
];
#[test_generator::test_resources("dev-test/spec/*.wast")]
fn translate_file(path: PathBuf) {
let path = path.strip_prefix("dev-test/").unwrap();
let name = path.file_name().unwrap().to_str().unwrap();
if DO_NOT_RUN.contains(&name) {
return;
}
let source = std::fs::read_to_string(path).unwrap();
LuaJIT::test(name, &source).unwrap();
}

176
dev-test/tests/luau_translate.rs Normal file
View File

@ -0,0 +1,176 @@
use std::{
io::{Result, Write},
path::PathBuf,
};
use wast::{
core::{Expression, Instruction},
token::{Float32, Float64},
AssertExpression, WastExecute, WastInvoke,
};
use target::{Target, TypedModule};
mod target;
static ASSERTION: &str = include_str!("assertion.lua");
struct Luau;
impl Luau {
fn write_i64(data: i64, w: &mut dyn Write) -> Result<()> {
let data_1 = (data & 0xFFFFFFFF) as u32;
let data_2 = (data >> 32 & 0xFFFFFFFF) as u32;
write!(w, "rt.num.from_u32({data_1}, {data_2})")
}
fn write_expression(data: &Expression, w: &mut dyn Write) -> Result<()> {
let data = &data.instrs;
assert_eq!(data.len(), 1, "Only one instruction supported");
match &data[0] {
Instruction::I32Const(v) => write!(w, "{v}"),
Instruction::I64Const(v) => Self::write_i64(*v, w),
Instruction::F32Const(v) => write!(w, "{}", f32::from_bits(v.bits)),
Instruction::F64Const(v) => write!(w, "{}", f64::from_bits(v.bits)),
_ => panic!("Unsupported instruction"),
}
}
write_assert_number!(write_assert_maybe_f32, Float32, f32);
write_assert_number!(write_assert_maybe_f64, Float64, f64);
fn write_simple_expression(data: &AssertExpression, w: &mut dyn Write) -> Result<()> {
match data {
AssertExpression::I32(v) => write!(w, "{v}"),
AssertExpression::I64(v) => Self::write_i64(*v, w),
AssertExpression::F32(v) => Self::write_assert_maybe_f32(v, w),
AssertExpression::F64(v) => Self::write_assert_maybe_f64(v, w),
_ => panic!("Unsupported expression"),
}
}
fn write_call_of(handler: &str, data: &WastInvoke, w: &mut dyn Write) -> Result<()> {
let name = TypedModule::resolve_id(data.module);
let func = data.name;
write!(w, "{handler}(")?;
write!(w, r#"loaded["{name}"].func_list["{func}"]"#)?;
data.args.iter().try_for_each(|v| {
write!(w, ", ")?;
Self::write_expression(v, w)
})?;
write!(w, ")")
}
}
impl Target for Luau {
fn executable() -> String {
std::env::var("LUAU_PATH").unwrap_or_else(|_| "luau".to_string())
}
fn write_register(post: &str, pre: &str, w: &mut dyn Write) -> Result<()> {
writeln!(w, r#"linked["{post}"] = loaded["{pre}"]"#)
}
fn write_invoke(data: &WastInvoke, w: &mut dyn Write) -> Result<()> {
Self::write_call_of("raw_invoke", data, w)?;
writeln!(w)
}
fn write_assert_trap(data: &WastExecute, w: &mut dyn Write) -> Result<()> {
match data {
WastExecute::Invoke(data) => {
Self::write_call_of("assert_trap", data, w)?;
writeln!(w)
}
WastExecute::Get { module, global } => {
let name = TypedModule::resolve_id(*module);
write!(w, "assert_neq(")?;
write!(w, r#"loaded["{name}"].global_list["{global}"].value"#)?;
writeln!(w, ", nil)")
}
WastExecute::Wat(_) => panic!("Wat not supported"),
}
}
fn write_assert_return(
data: &WastExecute,
result: &[AssertExpression],
w: &mut dyn Write,
) -> Result<()> {
match data {
WastExecute::Invoke(data) => {
write!(w, "assert_return(")?;
write!(w, "{{")?;
Self::write_call_of("raw_invoke", data, w)?;
write!(w, "}}, {{")?;
for v in result {
Self::write_simple_expression(v, w)?;
write!(w, ", ")?;
}
writeln!(w, "}})")
}
WastExecute::Get { module, global } => {
let name = TypedModule::resolve_id(*module);
write!(w, "assert_eq(")?;
write!(w, r#"loaded["{name}"].global_list["{global}"].value"#)?;
write!(w, ", ")?;
Self::write_simple_expression(&result[0], w)?;
writeln!(w, ")")
}
WastExecute::Wat(_) => panic!("Wat not supported"),
}
}
fn write_assert_exhaustion(data: &WastInvoke, w: &mut dyn Write) -> Result<()> {
Self::write_call_of("assert_exhaustion", data, w)?;
writeln!(w)
}
fn write_runtime(w: &mut dyn Write) -> Result<()> {
let runtime = codegen_luau::RUNTIME;
writeln!(w, "{ASSERTION}")?;
writeln!(w, "local rt = (function() {runtime} end)()")
}
fn write_module(typed: &TypedModule, w: &mut dyn Write) -> Result<()> {
write!(w, r#"loaded["{}"] = (function() "#, typed.name())?;
codegen_luau::from_module_typed(typed.module(), typed.type_info(), w)?;
writeln!(w, "end)()(nil)")
}
}
static DO_NOT_RUN: [&str; 8] = [
"binary-leb128.wast",
"conversions.wast",
"float_exprs.wast",
"float_literals.wast",
"float_memory.wast",
"float_misc.wast",
"names.wast",
"skip-stack-guard-page.wast",
];
#[test_generator::test_resources("dev-test/spec/*.wast")]
fn translate_file(path: PathBuf) {
let path = path.strip_prefix("dev-test/").unwrap();
let name = path.file_name().unwrap().to_str().unwrap();
if DO_NOT_RUN.contains(&name) {
return;
}
let source = std::fs::read_to_string(path).unwrap();
Luau::test(name, &source).unwrap();
}

389
dev-test/tests/spec_translate.rs
View File

@ -1,389 +0,0 @@
#![cfg(test)]
use std::{
io::{Result as IResult, Write},
marker::PhantomData,
path::{Path, PathBuf},
process::Command,
};
use parity_wasm::elements::Module as BinModule;
use wast::{
core::{Expression, Instruction, Module as AstModule},
parser::ParseBuffer,
token::{Float32, Float64, Id},
AssertExpression, NanPattern, QuoteWat, Wast, WastDirective, WastExecute, WastInvoke, Wat,
};
use wasm_ast::builder::TypeInfo;
static ASSERTION: &str = include_str!("assertion.lua");
macro_rules! write_assert_number {
($name:ident, $generic:ty, $reader:ty) => {
fn $name(data: &NanPattern<$generic>, w: &mut dyn Write) -> IResult<()> {
match data {
NanPattern::CanonicalNan => write!(w, "LUA_NAN_CANONICAL"),
NanPattern::ArithmeticNan => write!(w, "LUA_NAN_ARITHMETIC"),
NanPattern::Value(data) => {
let number = <$reader>::from_bits(data.bits);
let sign = if number.is_sign_negative() { "-" } else { "" };
if number.is_infinite() {
write!(w, "{sign}LUA_INFINITY")
} else if number.is_nan() {
write!(w, "{sign}LUA_NAN_DEFAULT")
} else {
write!(w, "{number}")
}
}
}
}
};
}
struct TypedModule<'a> {
name: &'a str,
module: &'a BinModule,
type_info: TypeInfo<'a>,
}
impl<'a> TypedModule<'a> {
fn resolve_id(id: Option<Id>) -> &str {
id.map_or("temp", |v| v.name())
}
fn from_id(id: Option<Id<'a>>, module: &'a BinModule) -> Self {
Self {
module,
name: Self::resolve_id(id),
type_info: TypeInfo::from_module(module),
}
}
}
trait Target: Sized {
fn executable() -> String;
fn write_register(post: &str, pre: &str, w: &mut dyn Write) -> IResult<()>;
fn write_invoke(data: &WastInvoke, w: &mut dyn Write) -> IResult<()>;
fn write_assert_trap(data: &WastExecute, w: &mut dyn Write) -> IResult<()>;
fn write_assert_return(
data: &WastExecute,
result: &[AssertExpression],
w: &mut dyn Write,
) -> IResult<()>;
fn write_assert_exhaustion(data: &WastInvoke, w: &mut dyn Write) -> IResult<()>;
fn write_runtime(w: &mut dyn Write) -> IResult<()>;
fn write_module(typed: &TypedModule, w: &mut dyn Write) -> IResult<()>;
}
struct LuaJIT;
impl LuaJIT {
fn write_expression(data: &Expression, w: &mut dyn Write) -> IResult<()> {
let data = &data.instrs;
assert_eq!(data.len(), 1, "Only one instruction supported");
match &data[0] {
Instruction::I32Const(v) => write!(w, "{v}"),
Instruction::I64Const(v) => write!(w, "{v}LL"),
Instruction::F32Const(v) => write!(w, "{}", f32::from_bits(v.bits)),
Instruction::F64Const(v) => write!(w, "{}", f64::from_bits(v.bits)),
_ => panic!("Unsupported instruction"),
}
}
write_assert_number!(write_assert_maybe_f32, Float32, f32);
write_assert_number!(write_assert_maybe_f64, Float64, f64);
fn write_simple_expression(data: &AssertExpression, w: &mut dyn Write) -> IResult<()> {
match data {
AssertExpression::I32(v) => write!(w, "{v}"),
AssertExpression::I64(v) => write!(w, "{v}LL"),
AssertExpression::F32(v) => Self::write_assert_maybe_f32(v, w),
AssertExpression::F64(v) => Self::write_assert_maybe_f64(v, w),
_ => panic!("Unsupported expression"),
}
}
fn write_call_of(handler: &str, data: &WastInvoke, w: &mut dyn Write) -> IResult<()> {
let name = TypedModule::resolve_id(data.module);
let func = data.name;
write!(w, "{handler}(")?;
write!(w, r#"loaded["{name}"].func_list["{func}"]"#)?;
data.args.iter().try_for_each(|v| {
write!(w, ", ")?;
Self::write_expression(v, w)
})?;
write!(w, ")")
}
}
impl Target for LuaJIT {
fn executable() -> String {
std::env::var("LUAJIT_PATH").unwrap_or_else(|_| "luajit".to_string())
}
fn write_register(post: &str, pre: &str, w: &mut dyn Write) -> IResult<()> {
writeln!(w, r#"linked["{post}"] = loaded["{pre}"]"#)
}
fn write_invoke(data: &WastInvoke, w: &mut dyn Write) -> IResult<()> {
Self::write_call_of("raw_invoke", data, w)?;
writeln!(w)
}
fn write_assert_trap(data: &WastExecute, w: &mut dyn Write) -> IResult<()> {
match data {
WastExecute::Invoke(data) => {
Self::write_call_of("assert_trap", data, w)?;
writeln!(w)
}
WastExecute::Get { module, global } => {
let name = TypedModule::resolve_id(*module);
write!(w, "assert_neq(")?;
write!(w, r#"loaded["{name}"].global_list["{global}"].value"#)?;
writeln!(w, ", nil)")
}
WastExecute::Wat(_) => panic!("Wat not supported"),
}
}
fn write_assert_return(
data: &WastExecute,
result: &[AssertExpression],
w: &mut dyn Write,
) -> IResult<()> {
match data {
WastExecute::Invoke(data) => {
write!(w, "assert_return(")?;
write!(w, "{{")?;
Self::write_call_of("raw_invoke", data, w)?;
write!(w, "}}, {{")?;
for v in result {
Self::write_simple_expression(v, w)?;
write!(w, ", ")?;
}
writeln!(w, "}})")
}
WastExecute::Get { module, global } => {
let name = TypedModule::resolve_id(*module);
write!(w, "assert_eq(")?;
write!(w, r#"loaded["{name}"].global_list["{global}"].value"#)?;
write!(w, ", ")?;
Self::write_simple_expression(&result[0], w)?;
writeln!(w, ")")
}
WastExecute::Wat(_) => panic!("Wat not supported"),
}
}
fn write_assert_exhaustion(data: &WastInvoke, w: &mut dyn Write) -> IResult<()> {
Self::write_call_of("assert_exhaustion", data, w)?;
writeln!(w)
}
fn write_runtime(w: &mut dyn Write) -> IResult<()> {
let runtime = codegen_luajit::RUNTIME;
writeln!(w, "{ASSERTION}")?;
writeln!(w, "local rt = (function() {runtime} end)()")
}
fn write_module(typed: &TypedModule, w: &mut dyn Write) -> IResult<()> {
write!(w, r#"loaded["{}"] = (function() "#, typed.name)?;
codegen_luajit::from_module_typed(typed.module, &typed.type_info, w)?;
writeln!(w, "end)()(nil)")
}
}
struct Luau;
impl Target for Luau {
fn executable() -> String {
std::env::var("LUAU_PATH").unwrap_or_else(|_| "luajit".to_string())
}
fn write_register(post: &str, pre: &str, w: &mut dyn Write) -> IResult<()> {
writeln!(w, r#"linked["{post}"] = loaded["{pre}"]"#)
}
fn write_invoke(data: &WastInvoke, w: &mut dyn Write) -> IResult<()> {
todo!();
}
fn write_assert_trap(data: &WastExecute, w: &mut dyn Write) -> IResult<()> {
todo!();
}
fn write_assert_return(
data: &WastExecute,
result: &[AssertExpression],
w: &mut dyn Write,
) -> IResult<()> {
todo!();
}
fn write_assert_exhaustion(data: &WastInvoke, w: &mut dyn Write) -> IResult<()> {
todo!();
}
fn write_runtime(w: &mut dyn Write) -> IResult<()> {
let runtime = codegen_luau::RUNTIME;
writeln!(w, "{ASSERTION}")?;
writeln!(w, "local rt = (function() {runtime} end)()")
}
fn write_module(typed: &TypedModule, w: &mut dyn Write) -> IResult<()> {
write!(w, r#"loaded["{}"] = (function() "#, typed.name)?;
codegen_luau::from_module_typed(typed.module, &typed.type_info, w)?;
writeln!(w, "end)()(nil)")
}
}
fn try_into_ast_module(data: QuoteWat) -> Option<AstModule> {
if let QuoteWat::Wat(Wat::Module(data)) = data {
Some(data)
} else {
None
}
}
// Only proceed with tests that observe any state.
fn parse_and_validate<'a>(buffer: &'a ParseBuffer) -> Option<Wast<'a>> {
let parsed: Wast = wast::parser::parse(buffer).unwrap();
let observer = parsed.directives.iter().any(|v| {
matches!(
v,
WastDirective::AssertTrap { .. }
| WastDirective::AssertReturn { .. }
| WastDirective::AssertExhaustion { .. }
)
});
observer.then(|| parsed)
}
struct Tester<T> {
_marker: PhantomData<T>,
}
impl<T: Target> Tester<T> {
fn test(name: &str, source: &str) -> IResult<()> {
if let Some(data) = Self::run_generation(source)? {
let temp = PathBuf::from(env!("CARGO_TARGET_TMPDIR"))
.join(name)
.with_extension("wast.lua");
std::fs::write(&temp, &data)?;
Self::run_command(&temp)?;
}
Ok(())
}
fn write_variant(variant: WastDirective, w: &mut dyn Write) -> IResult<()> {
match variant {
WastDirective::Wat(data) => {
let mut ast = try_into_ast_module(data).expect("Must be a module");
let bytes = ast.encode().unwrap();
let temp = parity_wasm::deserialize_buffer(&bytes).unwrap();
let typed = TypedModule::from_id(ast.id, &temp);
T::write_module(&typed, w)?;
}
WastDirective::Register { name, module, .. } => {
let pre = TypedModule::resolve_id(module);
T::write_register(name, pre, w)?;
}
WastDirective::Invoke(data) => {
T::write_invoke(&data, w)?;
}
WastDirective::AssertTrap { exec, .. } => {
T::write_assert_trap(&exec, w)?;
}
WastDirective::AssertReturn { exec, results, .. } => {
T::write_assert_return(&exec, &results, w)?;
}
WastDirective::AssertExhaustion { call, .. } => {
T::write_assert_exhaustion(&call, w)?;
}
_ => {}
}
Ok(())
}
fn run_command(file: &Path) -> IResult<()> {
let result = Command::new(T::executable()).arg(file).output()?;
if result.status.success() {
Ok(())
} else {
let data = String::from_utf8_lossy(&result.stderr);
panic!("{}", data);
}
}
fn run_generation(source: &str) -> IResult<Option<Vec<u8>>> {
let lexed = ParseBuffer::new(source).expect("Failed to tokenize");
let parsed = match parse_and_validate(&lexed) {
Some(v) => v,
None => return Ok(None),
};
let mut data = Vec::new();
T::write_runtime(&mut data)?;
for variant in parsed.directives {
Self::write_variant(variant, &mut data)?;
}
Ok(Some(data))
}
}
static DO_NOT_RUN: [&str; 8] = [
"binary-leb128.wast",
"conversions.wast",
"float_exprs.wast",
"float_literals.wast",
"float_memory.wast",
"float_misc.wast",
"names.wast",
"skip-stack-guard-page.wast",
];
#[test_generator::test_resources("dev-test/spec/*.wast")]
fn translate_file(path: PathBuf) {
let path = path.strip_prefix("dev-test/").unwrap();
let name = path.file_name().unwrap().to_str().unwrap();
if DO_NOT_RUN.contains(&name) {
return;
}
let source = std::fs::read_to_string(path).unwrap();
Tester::<LuaJIT>::test(name, &source).unwrap();
// Tester::<Luau>::test(name, &source).unwrap();
}

192
dev-test/tests/target.rs Normal file
View File

@ -0,0 +1,192 @@
use std::{
io::{Result, Write},
path::{Path, PathBuf},
process::Command,
};
use parity_wasm::elements::Module as BinModule;
use wast::{
core::Module as AstModule, parser::ParseBuffer, token::Id, AssertExpression, QuoteWat, Wast,
WastDirective, WastExecute, WastInvoke, Wat,
};
use wasm_ast::builder::TypeInfo;
#[macro_export]
macro_rules! write_assert_number {
($name:ident, $generic:ty, $reader:ty) => {
fn $name(data: &wast::NanPattern<$generic>, w: &mut dyn Write) -> Result<()> {
use wast::NanPattern;
match data {
NanPattern::CanonicalNan => write!(w, "LUA_NAN_CANONICAL"),
NanPattern::ArithmeticNan => write!(w, "LUA_NAN_ARITHMETIC"),
NanPattern::Value(data) => {
let number = <$reader>::from_bits(data.bits);
let sign = if number.is_sign_negative() { "-" } else { "" };
if number.is_infinite() {
write!(w, "{sign}LUA_INFINITY")
} else if number.is_nan() {
write!(w, "{sign}LUA_NAN_DEFAULT")
} else {
write!(w, "{number}")
}
}
}
}
};
}
pub struct TypedModule<'a> {
name: &'a str,
module: &'a BinModule,
type_info: TypeInfo<'a>,
}
impl<'a> TypedModule<'a> {
pub fn resolve_id(id: Option<Id>) -> &str {
id.map_or("temp", |v| v.name())
}
pub fn name(&self) -> &str {
self.name
}
pub fn module(&self) -> &BinModule {
self.module
}
pub fn type_info(&self) -> &TypeInfo<'a> {
&self.type_info
}
fn from_id(id: Option<Id<'a>>, module: &'a BinModule) -> Self {
Self {
module,
name: Self::resolve_id(id),
type_info: TypeInfo::from_module(module),
}
}
}
fn try_into_ast_module(data: QuoteWat) -> Option<AstModule> {
if let QuoteWat::Wat(Wat::Module(data)) = data {
Some(data)
} else {
None
}
}
// Only proceed with tests that observe any state.
fn parse_and_validate<'a>(buffer: &'a ParseBuffer) -> Option<Wast<'a>> {
let parsed: Wast = wast::parser::parse(buffer).unwrap();
let observer = parsed.directives.iter().any(|v| {
matches!(
v,
WastDirective::AssertTrap { .. }
| WastDirective::AssertReturn { .. }
| WastDirective::AssertExhaustion { .. }
)
});
observer.then(|| parsed)
}
pub trait Target: Sized {
fn executable() -> String;
fn write_register(post: &str, pre: &str, w: &mut dyn Write) -> Result<()>;
fn write_invoke(data: &WastInvoke, w: &mut dyn Write) -> Result<()>;
fn write_assert_trap(data: &WastExecute, w: &mut dyn Write) -> Result<()>;
fn write_assert_return(
data: &WastExecute,
result: &[AssertExpression],
w: &mut dyn Write,
) -> Result<()>;
fn write_assert_exhaustion(data: &WastInvoke, w: &mut dyn Write) -> Result<()>;
fn write_runtime(w: &mut dyn Write) -> Result<()>;
fn write_module(typed: &TypedModule, w: &mut dyn Write) -> Result<()>;
fn write_variant(variant: WastDirective, w: &mut dyn Write) -> Result<()> {
match variant {
WastDirective::Wat(data) => {
let mut ast = try_into_ast_module(data).expect("Must be a module");
let bytes = ast.encode().unwrap();
let temp = parity_wasm::deserialize_buffer(&bytes).unwrap();
let typed = TypedModule::from_id(ast.id, &temp);
Self::write_module(&typed, w)?;
}
WastDirective::Register { name, module, .. } => {
let pre = TypedModule::resolve_id(module);
Self::write_register(name, pre, w)?;
}
WastDirective::Invoke(data) => {
Self::write_invoke(&data, w)?;
}
WastDirective::AssertTrap { exec, .. } => {
Self::write_assert_trap(&exec, w)?;
}
WastDirective::AssertReturn { exec, results, .. } => {
Self::write_assert_return(&exec, &results, w)?;
}
WastDirective::AssertExhaustion { call, .. } => {
Self::write_assert_exhaustion(&call, w)?;
}
_ => {}
}
Ok(())
}
fn run_command(file: &Path) -> Result<()> {
let result = Command::new(Self::executable()).arg(file).output()?;
if result.status.success() {
Ok(())
} else {
let data = String::from_utf8_lossy(&result.stderr);
panic!("{}", data);
}
}
fn run_generation(source: &str) -> Result<Option<Vec<u8>>> {
let lexed = ParseBuffer::new(source).expect("Failed to tokenize");
let parsed = match parse_and_validate(&lexed) {
Some(v) => v,
None => return Ok(None),
};
let mut data = Vec::new();
Self::write_runtime(&mut data)?;
for variant in parsed.directives {
Self::write_variant(variant, &mut data)?;
}
Ok(Some(data))
}
fn test(name: &str, source: &str) -> Result<()> {
if let Some(data) = Self::run_generation(source)? {
let temp = PathBuf::from(env!("CARGO_TARGET_TMPDIR"))
.join(name)
.with_extension("wast.lua");
std::fs::write(&temp, &data)?;
Self::run_command(&temp)?;
}
Ok(())
}
}