#[path = "support/stack_corpus.rs"]
mod stack_corpus;
use std::collections::BTreeMap;
use nybl::{NyblError, NyblHost, NyblLimits, Value};
use stack_corpus::Shape;
const RELEASE_STACK: usize = 10 * 1024 * 1024;
const DEBUG_STACK: usize = 128 * 1024 * 1024;
fn documented_stack() -> usize {
if cfg!(debug_assertions) {
DEBUG_STACK
} else {
RELEASE_STACK
}
}
struct ModuleHost {
modules: BTreeMap<String, String>,
}
impl NyblHost for ModuleHost {
fn call(&mut self, _: &str, _: &[Value], _: u32) -> Option<Result<Value, NyblError>> {
None
}
fn resolve_module(&mut self, name: &str) -> Option<Result<String, NyblError>> {
self.modules.get(name).cloned().map(Ok)
}
}
type Engine = fn(&str, &mut ModuleHost, &NyblLimits) -> Result<(), NyblError>;
fn run_corpus(engine: Engine) -> Vec<String> {
std::thread::Builder::new()
.stack_size(documented_stack())
.spawn(move || {
let shapes: Vec<Shape> = stack_corpus::corpus();
shapes
.iter()
.filter_map(|shape| {
let mut host = ModuleHost {
modules: shape.modules.iter().cloned().collect(),
};
let outcome = match engine(&shape.source, &mut host, &NyblLimits::standard()) {
Ok(()) => "succeeded".to_string(),
Err(error) if shape.accepts(&error.message) => return None,
Err(error) => error.message,
};
Some(format!("{}: {outcome}", shape.name))
})
.collect()
})
.expect("spawn stack-bound thread")
.join()
.expect("stack-bound thread panicked")
}
#[test]
fn walker_corpus_ends_cleanly_on_the_documented_stack() {
let unexpected = run_corpus(nybl::run);
assert!(unexpected.is_empty(), "{unexpected:#?}");
}
#[test]
fn vm_corpus_ends_cleanly_on_the_documented_stack() {
let unexpected = run_corpus(nybl_vm::run);
assert!(unexpected.is_empty(), "{unexpected:#?}");
}