zaphar/ucg
1
0
Fork 0
mirror of https://github.com/zaphar/ucg.git synced 2025-07-22 18:19:54 -04:00
Code Issues Packages Projects Releases Wiki Activity

DEV: DSL for table based testing using macros.

Browse Source
This commit is contained in:
Jeremy Wall 2019-07-08 20:11:19 -05:00
parent 3bb6f6e8eb
commit aac263be2c
1 changed files with 314 additions and 412 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

244
src/build/opcode/test.rs
View File

@ -22,32 +22,48 @@ use super::Primitive::{Bool, Float, Int, Str};
use super::Value::{C, P, T};
use super::VM;
macro_rules! assert_cases {
(__impl__ $cases:expr) => {
for case in $cases.drain(0..) {
let mut vm = VM::new(&case.0);
vm.run().unwrap();
assert_eq!(vm.pop().unwrap(), case.1);
}
};
(($input:expr, $result:expr), $($tok:tt)*) => {
assert_cases!(__impl__ vec![($input, $result), $($tok)*])
};
($($input:expr => $result:expr, )* ) => {
assert_cases!(
$(($input, $result),)*
)
}
}
#[test]
fn test_math_ops() {
let mut cases = vec![
assert_cases!(
// 1+1;
(vec![Val(Int(1)), Val(Int(1)), Add], P(Int(2))),
vec![Val(Int(1)), Val(Int(1)), Add] => P(Int(2)),
// 1-1;
(vec![Val(Int(1)), Val(Int(1)), Sub], P(Int(0))),
vec![Val(Int(1)), Val(Int(1)), Sub] => P(Int(0)),
// 2*2;
(vec![Val(Int(2)), Val(Int(2)), Mul], P(Int(4))),
vec![Val(Int(2)), Val(Int(2)), Mul] => P(Int(4)),
// 6/3;
(vec![Val(Int(2)), Val(Int(6)), Div], P(Int(3))),
vec![Val(Int(2)), Val(Int(6)), Div] => P(Int(3)),
// 1.0+1.0;
(vec![Val(Float(1.0)), Val(Float(1.0)), Add], P(Float(2.0))),
vec![Val(Float(1.0)), Val(Float(1.0)), Add] => P(Float(2.0)),
// 1.0-1.0;
(vec![Val(Float(1.0)), Val(Float(1.0)), Sub], P(Float(0.0))),
vec![Val(Float(1.0)), Val(Float(1.0)), Sub] => P(Float(0.0)),
// 2.0*2.0;
(vec![Val(Float(2.0)), Val(Float(2.0)), Mul], P(Float(4.0))),
vec![Val(Float(2.0)), Val(Float(2.0)), Mul] => P(Float(4.0)),
// 6.0/3.0;
(vec![Val(Float(2.0)), Val(Float(6.0)), Div], P(Float(3.0))),
vec![Val(Float(2.0)), Val(Float(6.0)), Div] => P(Float(3.0)),
// string concatenation
(
vec![Val(Str("bar".to_owned())), Val(Str("foo".to_owned())), Add],
P(Str("foobar".to_owned())),
),
vec![Val(Str("bar".to_owned())), Val(Str("foo".to_owned())), Add] => P(Str("foobar".to_owned())),
// Composite operations
(
vec![
Val(Int(1)),
Val(Int(1)),
@ -56,15 +72,8 @@ fn test_math_ops() {
Add, // 2 + 1
Val(Int(1)),
Add, // 3 + 1
],
P(Int(4)),
),
];
for case in cases.drain(0..) {
let mut vm = VM::new(&case.0);
vm.run().unwrap();
assert_eq!(vm.pop().unwrap(), case.1);
}
] => P(Int(4)),
);
}
#[test]
@ -87,17 +96,10 @@ fn test_bind_op() {
#[test]
fn test_list_ops() {
let mut cases = vec![
(vec![InitList], C(List(Vec::new()))),
(
vec![InitList, Val(Int(1)), Element],
C(List(vec![P(Int(1))])),
),
(
vec![InitList, Val(Int(2)), Element, Val(Int(1)), Element],
C(List(vec![P(Int(2)), P(Int(1))])),
),
(
assert_cases!(
vec![InitList] => C(List(Vec::new())),
vec![InitList, Val(Int(1)), Element] => C(List(vec![P(Int(1))])),
vec![InitList, Val(Int(2)), Element, Val(Int(1)), Element] => C(List(vec![P(Int(2)), P(Int(1))])),
vec![
InitList,
Val(Int(1)),
@ -106,26 +108,15 @@ fn test_list_ops() {
Val(Int(1)),
Add,
Element,
],
C(List(vec![P(Int(1)), P(Int(2))])),
),
];
for case in cases.drain(0..) {
let mut vm = VM::new(&case.0);
vm.run().unwrap();
assert_eq!(vm.pop().unwrap(), case.1);
}
] => C(List(vec![P(Int(1)), P(Int(2))])),
);
}
#[test]
fn test_tuple_ops() {
let mut cases = vec![
(vec![InitTuple], C(Tuple(Vec::new()))),
(
vec![InitTuple, Val(Str("foo".to_owned())), Val(Int(1)), Field],
C(Tuple(vec![("foo".to_owned(), P(Int(1)))])),
),
(
assert_cases!(
vec![InitTuple] => C(Tuple(Vec::new())),
vec![InitTuple, Val(Str("foo".to_owned())), Val(Int(1)), Field] => C(Tuple(vec![("foo".to_owned(), P(Int(1)))])),
vec![
InitTuple,
Sym("bar".to_owned()),
@ -134,13 +125,10 @@ fn test_tuple_ops() {
Val(Str("foo".to_owned())),
Val(Int(1)),
Field,
],
C(Tuple(vec![
] => C(Tuple(vec![
("bar".to_owned(), P(Str("quux".to_owned()))),
("foo".to_owned(), P(Int(1))),
])),
),
(
vec![
InitTuple,
Sym("bar".to_owned()),
@ -152,13 +140,10 @@ fn test_tuple_ops() {
Val(Str("foo".to_owned())),
Val(Int(2)),
Field,
],
C(Tuple(vec![
] => C(Tuple(vec![
("bar".to_owned(), P(Str("quux".to_owned()))),
("foo".to_owned(), P(Int(2))),
])),
),
(
vec![
InitTuple,
Sym("bar".to_owned()),
@ -172,13 +157,10 @@ fn test_tuple_ops() {
Val(Str("foo".to_owned())),
Val(Int(2)),
Field,
],
C(Tuple(vec![
] => C(Tuple(vec![
("bar".to_owned(), P(Str("quux".to_owned()))),
("foo".to_owned(), P(Int(2))),
])),
),
(
vec![
InitTuple, // Override tuple
Val(Str("foo".to_owned())),
@ -194,64 +176,39 @@ fn test_tuple_ops() {
Val(Int(1)),
Field,
Cp, // Do the tuple copy operation
],
C(Tuple(vec![
] => C(Tuple(vec![
("bar".to_owned(), P(Str("quux".to_owned()))),
("foo".to_owned(), P(Int(2))),
])),
),
];
for case in cases.drain(0..) {
let mut vm = VM::new(&case.0);
vm.run().unwrap();
assert_eq!(vm.pop().unwrap(), case.1);
}
);
}
#[test]
fn test_jump_ops() {
let mut cases = vec![
(vec![InitThunk(1), Val(Int(1)), Noop], T(0)),
(vec![Jump(1), Val(Int(1)), Noop, Val(Int(1))], P(Int(1))),
];
for case in cases.drain(0..) {
let mut vm = VM::new(&case.0);
vm.run().unwrap();
assert_eq!(vm.pop().unwrap(), case.1);
}
assert_cases!(
vec![InitThunk(1), Val(Int(1)), Noop] => T(0),
vec![Jump(1), Val(Int(1)), Noop, Val(Int(1))] => P(Int(1)),
);
}
#[test]
fn test_equality_ops() {
let mut cases = vec![
(
assert_cases![
vec![
Val(Str("foo".to_owned())),
Val(Str("foo".to_owned())),
Equal,
],
P(Bool(true)),
),
(
] => P(Bool(true)),
vec![
Val(Str("bar".to_owned())),
Val(Str("foo".to_owned())),
Equal,
],
P(Bool(false)),
),
(vec![Val(Int(1)), Val(Int(1)), Equal], P(Bool(true))),
(vec![Val(Int(1)), Val(Int(2)), Equal], P(Bool(false))),
(vec![Val(Bool(true)), Val(Bool(true)), Equal], P(Bool(true))),
(
vec![Val(Bool(false)), Val(Bool(false)), Equal],
P(Bool(true)),
),
(
vec![Val(Bool(true)), Val(Bool(false)), Equal],
P(Bool(false)),
),
(
] => P(Bool(false)),
vec![Val(Int(1)), Val(Int(1)), Equal] => P(Bool(true)),
vec![Val(Int(1)), Val(Int(2)), Equal] => P(Bool(false)),
vec![Val(Bool(true)), Val(Bool(true)), Equal] => P(Bool(true)),
vec![Val(Bool(false)), Val(Bool(false)), Equal] => P(Bool(true)),
vec![Val(Bool(true)), Val(Bool(false)), Equal] => P(Bool(false)),
vec![
InitTuple,
Val(Str("foo".to_owned())),
@ -262,10 +219,7 @@ fn test_equality_ops() {
Val(Int(1)),
Field,
Equal,
],
P(Bool(true)),
),
(
] => P(Bool(true)),
vec![
InitTuple,
Val(Str("foo".to_owned())),
@ -276,10 +230,7 @@ fn test_equality_ops() {
Val(Int(1)),
Field,
Equal,
],
P(Bool(false)),
),
(
] => P(Bool(false)),
vec![
InitList,
Val(Str("foo".to_owned())),
@ -288,10 +239,7 @@ fn test_equality_ops() {
Val(Str("foo".to_owned())),
Element,
Equal,
],
P(Bool(true)),
),
(
] => P(Bool(true)),
vec![
InitList,
Val(Str("foo".to_owned())),
@ -300,21 +248,13 @@ fn test_equality_ops() {
Val(Str("bar".to_owned())),
Element,
Equal,
],
P(Bool(false)),
),
] => P(Bool(false)),
];
for case in cases.drain(0..) {
let mut vm = VM::new(&case.0);
vm.run().unwrap();
assert_eq!(vm.pop().unwrap(), case.1);
}
}
#[test]
fn test_conditional_jump_ops() {
let mut cases = vec![
(
assert_cases![
vec![
Val(Bool(false)),
JumpIfTrue(2),
@ -324,10 +264,7 @@ fn test_conditional_jump_ops() {
Jump(1),
Val(Int(2)),
Noop,
],
P(Int(2)),
),
(
] => P(Int(2)),
vec![
Val(Bool(true)),
JumpIfTrue(2),
@ -337,10 +274,7 @@ fn test_conditional_jump_ops() {
Jump(1),
Val(Int(2)),
Noop,
],
P(Int(1)),
),
(
] => P(Int(1)),
vec![
Val(Int(1)),
Val(Int(1)),
@ -352,10 +286,7 @@ fn test_conditional_jump_ops() {
Jump(1),
Val(Int(2)),
Noop,
],
P(Int(1)),
),
(
] => P(Int(1)),
vec![
Val(Int(1)),
Val(Int(2)),
@ -367,21 +298,13 @@ fn test_conditional_jump_ops() {
Jump(1),
Val(Int(2)),
Noop,
],
P(Int(1)),
),
] => P(Int(1)),
];
for case in cases.drain(0..) {
let mut vm = VM::new(&case.0);
vm.run().unwrap();
assert_eq!(vm.pop().unwrap(), case.1);
}
}
#[test]
fn test_function_definition_and_call() {
let mut cases = vec![
(
assert_cases![
vec![
Sym("f".to_owned()), // 0
InitList, // 1
@ -394,10 +317,7 @@ fn test_function_definition_and_call() {
Val(Int(1)), // 8
DeRef("f".to_owned()), // 9
FCall, // 10
],
P(Int(1)),
),
(
] => P(Int(1)),
vec![
Sym("closed".to_owned()), // 0
Val(Int(1)), // 1
@ -415,21 +335,13 @@ fn test_function_definition_and_call() {
Val(Int(1)), // 13
DeRef("f".to_owned()), // 14
FCall, // 16
],
P(Int(2)),
),
] => P(Int(2)),
];
for case in cases.drain(0..) {
let mut vm = VM::new(&case.0);
vm.run().unwrap();
assert_eq!(vm.pop().unwrap(), case.1);
}
}
#[test]
fn test_module_call() {
let mut cases = vec![
(
assert_cases![
vec![
InitTuple, // 0 // override tuple
Sym("one".to_owned()), // 1
@ -452,16 +364,13 @@ fn test_module_call() {
Bind, // 18 // bind module to the binding name
DeRef("m".to_owned()), // 19
Cp, // 20
],
C(Tuple(vec![(
] => C(Tuple(vec![(
"foo".to_owned(),
C(Tuple(vec![
("one".to_owned(), P(Int(11))),
("two".to_owned(), P(Int(2))),
])),
)])),
),
(
vec![
InitTuple, // 0 // override tuple
Sym("one".to_owned()), // 1
@ -487,15 +396,8 @@ fn test_module_call() {
Bind, // 21 // bind module to the binding name
DeRef("m".to_owned()), // 22
Cp, // 23
],
P(Int(1)),
),
] => P(Int(1)),
];
for case in cases.drain(0..) {
let mut vm = VM::new(&case.0);
vm.run().unwrap();
assert_eq!(vm.pop().unwrap(), case.1);
}
}
#[test]