reactor
/
lunar_wave
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
lunar_wave/lunar_wave_vm/src/tests.rs

542 lines
12 KiB
Rust
Raw Blame History

use std::{
hash::Hash,
rc::Rc,
};
use crate::{
instruction::Instruction as Inst,
loader::{
self,
DecodeInstruction,
},
state::{
Block,
Chunk,
State,
},
string_interner::Interner,
value::Value,
};
fn calculate_hash<T: Hash>(t: &T) -> u64 {
use std::hash::Hasher;
let mut s = std::collections::hash_map::DefaultHasher::new ();
t.hash(&mut s);
s.finish()
}
/// Takes arguments and a parsed Lua chunk, runs its,
/// and returns the output
fn run_chunk (vm: &mut State, args: &[&str], chunk: Chunk) -> Vec <Value> {
vm.upvalues = vm.upvalues_from_args(args.into_iter ().map (|s| s.to_string ()));
vm.set_chunk (chunk);
vm.execute ().unwrap ()
}
/// Takes arguments and Lua bytecode, loads it, runs it,
/// and return the output
fn run_bytecode (vm: &mut State, args: &[&str], bc: &[u8]) -> Vec <Value> {
let chunk = loader::parse_chunk (&bc, &mut vm.si).unwrap ();
run_chunk (vm, args, chunk)
}
/// Takes arguments and Lua source code,
/// invokes `luac` to compile it to bytecode,
/// runs it, and returns the output
fn run_source (vm: &mut State, args: &[&str], s: &str) -> Vec <Value> {
let bc = loader::compile_bytecode (s.as_bytes ().to_vec ()).unwrap ();
run_bytecode (vm, args, &bc)
}
#[test]
fn bools () {
/*
local function bool_to_x (b)
if b then
return 99
else
return 98
end
end
local x = bool_to_x (not not arg [1])
print (x)
return x
*/
let mut si = Interner::default ();
/*
let chunk = Chunk {
blocks: vec! [
Block {
instructions: vec! [
Inst::VarArgPrep (0),
Inst::Closure (0, 0),
Inst::Move (1, 0),
Inst::LoadFalse (2),
Inst::Call (1, 2, 1),
Inst::Move (1, 0),
Inst::LoadTrue (2),
Inst::Call (1, 2, 1),
Inst::Move (1, 0),
Inst::GetTabUp (2, 0, 0),
Inst::GetI (2, 2, 1),
Inst::Not (2, 2),
Inst::Not (2, 2),
Inst::Call (1, 2, 2),
Inst::GetTabUp (2, 0, 1),
Inst::Move (3, 1),
Inst::Call (2, 2, 1),
Inst::Return (1, 2, 1, false),
Inst::Return (2, 1, 1, false),
],
constants: vec! [
si.to_value ("arg"),
si.to_value ("print"),
],
upvalues: vec! [],
}.into (),
Block {
instructions: vec! [
Inst::Test (0, false),
Inst::Jmp (3),
Inst::LoadI (1, 99),
Inst::Return1 (1),
Inst::Jmp (2),
Inst::LoadI (1, 98),
Inst::Return1 (1),
Inst::Return0,
],
constants: vec! [],
upvalues: vec! [],
}.into (),
],
};
let mut vm = crate::State::new_with_args (Chunk::default (), si, vec! [].into_iter());
for (arg, expected) in [
(vec! ["_exe_name"], vec! [98.into ()]),
(vec! ["_exe_name", "asdf"], vec! [99.into ()]),
] {
let expected: Vec <Value> = expected;
let actual = run_chunk (&mut vm, &arg, chunk.clone ());
assert_eq! (actual, expected);
}
*/
}
#[test]
fn closure () {
let source = include_bytes! ("../test_vectors/closure.lua");
let bytecode = &crate::loader::compile_bytecode (source.to_vec ()).unwrap ();
let mut si = Interner::default ();
let chunk = crate::loader::parse_chunk (bytecode, &mut si).unwrap ();
let mut vm = crate::State::new_with_args (Chunk::default (), si, vec! [].into_iter());
assert_eq! (run_chunk (&mut vm, &["_exe_name"], chunk), vec! [Value::from (23i64)]);
}
#[test]
fn floats () {
/*
local a = 0.5
local b = 3
local x = a + b
print (x)
return x
*/
let mut si = Interner::default ();
/*
let block = Block {
instructions: vec! [
Inst::VarArgPrep (0),
Inst::LoadK (0, 0),
Inst::LoadI (1, 3),
Inst::Add (2, 0, 1),
Inst::MmBin (0, 1, 6),
Inst::GetTabUp (3, 0, 1),
Inst::Move (4, 2),
Inst::Call (3, 2, 1),
Inst::Return (2, 2, 1, false),
Inst::Return (3, 1, 1, false),
],
constants: vec! [
0.5.into (),
si.to_value ("print"),
],
upvalues: vec! [],
};
let chunk = Chunk {
blocks: vec! [block.into ()],
};
let mut vm = crate::State::new_with_args (Chunk::default (), si, vec! [].into_iter());
for (arg, expected) in [
(vec! ["_exe_name"], vec! [3.5.into ()]),
(vec! ["_exe_name", " "], vec! [3.5.into ()]),
] {
let expected: Vec <Value> = expected;
let actual = run_chunk (&mut vm, &arg, chunk.clone ());
assert_eq! (actual, expected);
}
*/
}
#[test]
fn fma () {
let source = include_bytes! ("../test_vectors/fma.lua");
let mut si = Interner::default ();
let bytecode = &crate::loader::compile_bytecode (source.to_vec ()).unwrap ();
let chunk = crate::loader::parse_chunk (bytecode, &mut si).unwrap ();
assert_eq! (chunk.blocks.len (), 5);
assert_eq! (chunk.blocks [3].upvalues.len (), 2);
let i = chunk.blocks [1].instructions [0];
assert_eq! (i.opcode (), 0x22);
assert_eq! (i.a (), 2);
assert_eq! (i.b (), 0);
assert_eq! (i.c (), 1);
let i = chunk.blocks [1].instructions [1];
assert_eq! (i.opcode (), 0x2e);
assert_eq! (i.a (), 0);
assert_eq! (i.b (), 1);
assert_eq! (i.c (), 6);
let i = chunk.blocks [2].instructions [0];
assert_eq! (i.opcode (), 0x24);
assert_eq! (i.a (), 2);
assert_eq! (i.b (), 0);
assert_eq! (i.c (), 1);
let i = chunk.blocks [2].instructions [1];
assert_eq! (i.opcode (), 0x2e);
assert_eq! (i.a (), 0);
assert_eq! (i.b (), 1);
assert_eq! (i.c (), 8);
let i = chunk.blocks [3].instructions [2];
assert_eq! (i.opcode (), 0x00);
assert_eq! (i.a (), 5);
assert_eq! (i.b (), 0);
let i = chunk.blocks [3].instructions [4];
assert_eq! (i.opcode (), 0x44);
assert_eq! (i.a (), 4);
assert_eq! (i.b (), 3);
assert_eq! (i.c (), 2);
let i = chunk.blocks [4].instructions [1];
assert_eq! (i.opcode (), 0x01);
assert_eq! (i.a (), 1);
assert_eq! (i.sbx (), 10);
let mut vm = crate::State::new_with_args (chunk, si, vec! ["_exe_name".to_string ()].into_iter ());
let actual = vm.execute ().unwrap ();
let expected = vec! [Value::from (122)];
assert_eq! (actual, expected);
}
#[test]
fn function_calls () {
let si = Interner::default ();
let mut vm = crate::State::new_with_args (crate::Chunk::default (), si, vec! ["_exe_name".to_string ()].into_iter ());
vm.eval ("print (x ())").ok ();
vm.eval ("x = function () return 5 end").ok ();
// Currently failing because I don't have a way to jump into a Lua
// function that's no longer in the currently-executing chunk
vm.eval ("print (x ())").ok ();
}
#[test]
fn function_returns () {
let si = Interner::default ();
let mut vm = crate::State::new_with_args (crate::Chunk::default (), si, vec! ["_exe_name".to_string ()].into_iter ());
assert_eq! (
vm.eval ("return ((function () return 5 end)())").unwrap (),
vec! [Value::from (5)]
);
assert_eq! (
vm.eval ("return (math.sqrt (25))").unwrap (),
vec! [Value::from (5.0)]
);
}
#[test]
fn heap () {
use std::{
cell::RefCell,
collections::HashMap,
rc::Rc,
};
use crate::value::Table;
let mut si = Interner::default ();
{
let mut allocations = HashMap::new ();
let mut ctr = 0;
let c = ctr;
allocations.insert (ctr, Table::default ());
ctr += 1;
let a = ctr;
allocations.insert (ctr, Table::default ());
ctr += 1;
allocations.get_mut (&a).unwrap ().insert (1, c);
allocations.get_mut (&c).unwrap ().insert (2, si.to_value ("eee"));
}
if true {
#[derive (Clone, Debug, PartialEq)]
enum Value {
S (Rc <String>),
T (Rc <RefCell <HashMap <i64, Value>>>),
}
let c = Value::T (Default::default ());
let a = Value::T (Default::default ());
match &a {
Value::T (t) => t.borrow_mut ().insert (1, c.clone ()),
_ => panic! ("impossible"),
};
match &c {
Value::T (t) => t.borrow_mut ().insert (2, Value::S (Rc::new (String::from ("eee")))),
_ =>panic! ("impossible"),
};
let actual = match &a {
Value::T (t) => match t.borrow ().get (&1) {
Some (Value::T (t)) => t.borrow ().get (&2).unwrap ().clone (),
_ => panic! ("impossible"),
},
_ => panic! ("impossible"),
};
assert_eq! (actual, Value::S (Rc::new ("eee".into ())));
}
}
#[test]
fn is_93 () {
let mut si = Interner::default ();
assert_eq! (si.to_value ("93"), si.to_value ("93"));
assert_ne! (si.to_value ("94"), si.to_value ("93"));
assert_ne! (calculate_hash (&si.to_value ("94")), calculate_hash (&si.to_value ("93")));
assert_ne! (Value::Nil, si.to_value ("93"));
let src = br#"
if arg [1] == "93" then
print "it's 93"
return 0
else
print "it's not 93"
return 1
end
"#;
let bc = loader::compile_bytecode (src.to_vec ()).unwrap ();
let chunk = loader::parse_chunk (&bc, &mut si).unwrap ();
let i = chunk.blocks [0].instructions [3];
assert_eq! (i.opcode (), 0x3c);
assert_eq! (i.a (), 0);
assert_eq! (i.b (), 1);
assert_eq! (i.k (), false);
let i = chunk.blocks [0].instructions [4];
assert_eq! (i.opcode (), 0x38);
assert_eq! (i.sj (), 6);
let mut vm = crate::State::new_with_args (Chunk::default (), si, vec! [].into_iter());
let run = run_chunk;
assert_eq! (run (&mut vm, &[""], chunk.clone ()), vec! [Value::from (1)]);
assert_eq! (run (&mut vm, &["", "93"], chunk.clone ()), vec! [Value::from (0)]);
assert_eq! (run (&mut vm, &["", "94"], chunk.clone ()), vec! [Value::from (1)]);
}
#[test]
fn native_functions () {
fn add (_: &mut State) -> i32 {
0
}
fn multiply (_: &mut State) -> i32 {
0
}
fn greet (_: &mut State) -> i32 {
0
}
let _funcs = [
add,
multiply,
greet,
];
}
#[test]
fn tables_1 () {
// I don't capture stdout yet, but I can at least make sure basic table
// operations don't crash
let src = r#"
print " 1"
print (nil)
print (false)
print (true)
print (1993)
print (1993.00)
print "Hello."
print " 2"
local t = {}
print (t)
print (t [1])
t [1] = "asdf"
print (t [1])
t.x = 1993
print (t.x)
t.t = { 3.14159 }
print (t ["t"][1])
"#;
let si = Interner::default ();
let mut vm = crate::State::new_with_args (Chunk::default (), si, vec! [].into_iter());
run_source (&mut vm, &[], src);
}
#[test]
fn tables_2 () {
let src = r#"
print " 3"
local c = {}
local a = { c }
print (a [1])
c [2] = "eee"
print (a [2])
"#;
let si = Interner::default ();
let mut vm = crate::State::new_with_args (Chunk::default (), si, vec! [].into_iter());
run_source (&mut vm, &[], src);
}
#[test]
fn tailcall () {
let mut si = Interner::default ();
let src = br#"
return tonumber ("5")
"#;
let bc = loader::compile_bytecode (src.to_vec ()).unwrap ();
let chunk = loader::parse_chunk (&bc, &mut si).unwrap ();
// assert_eq! (chunk.blocks [0].instructions [3].opcode (), Instruction::TailCall (0, 2, 1, false));
assert_eq! (chunk.blocks [0].instructions [3].opcode (), 0x45);
let mut vm = crate::State::new_with_args (Chunk::default (), si, vec! [].into_iter());
let actual = run_chunk (&mut vm, &[], chunk);
let expected = vec! [Value::from (5)];
assert_eq! (actual, expected);
}
#[test]
fn rust_stuff () {
// Per https://www.lua.org/doc/jucs05.pdf,
// "The Implementation of Lua 5.0",
//
// Lua's tagged union values are 12-16 bytes on a 32-bit system
// with 64-bit floats
//
// It would be nice if LunarWaveVM is the same or better.
// I'm also just checking a bunch of my assumptions about how
// Rust organizes and sizes different types
use std::mem::size_of;
{
// Make sure that Rx / Box are both pointers that hide the size
// of big types
assert! (size_of::<Box <()>> () <= 8);
assert! (size_of::<std::rc::Rc <()>> () <= 8);
}
{
// Make sure LWVM's Values are 16 bytes or smaller.
// Because types are usually aligned to their size, f64s
// are supposed to be aligned to 8 bytes. So even an `Option <f64>`
// uses 8 bytes to say "Some" or "None".
// I could _maybe_ fudge this somehow but it's fine to start with.
let sz = size_of::<crate::value::Value> ();
let expected = 16;
assert! (sz <= expected, "{sz} > {expected}");
}
{
// All these are 8 bytes for the same reason Value is 16 bytes.
// Luckily Rust doesn't seem to stack the 4-byte overhead
// of Result and Option.
let sz = size_of::<(i32, i32)> ();
let expected = 8;
assert! (sz == expected, "{sz} != {expected}");
let sz = size_of::<Option <i32>> ();
let expected = 8;
assert! (sz == expected, "{sz} != {expected}");
let sz = size_of::<Result <i32, i32>> ();
let expected = 8;
assert! (sz == expected, "{sz} != {expected}");
let sz = size_of::<Result <Option <i32>, i32>> ();
let expected = 8;
assert! (sz == expected, "{sz} != {expected}");
}
assert_eq! (size_of::<crate::instruction::Instruction> (), 8);
let x = vec! [100, 101, 102, 103];
let x: Rc <[u32]> = Rc::from (x);
}
Reference in New Issue View Git Blame Copy Permalink