Init

tests/forth/stack.rs

@@ -0,0 +1,94 @@
+use super::harness::*;
+use seq::model::forth::Value;
+
+fn int(n: i64) -> Value {
+    Value::Int(n, None)
+}
+
+#[test]
+fn dup() {
+    expect_stack("3 dup", &[int(3), int(3)]);
+}
+
+#[test]
+fn dup_underflow() {
+    expect_error("dup", "stack underflow");
+}
+
+#[test]
+fn drop() {
+    expect_stack("1 2 drop", &[int(1)]);
+}
+
+#[test]
+fn drop_underflow() {
+    expect_error("drop", "stack underflow");
+}
+
+#[test]
+fn swap() {
+    expect_stack("1 2 swap", &[int(2), int(1)]);
+}
+
+#[test]
+fn swap_underflow() {
+    expect_error("1 swap", "stack underflow");
+}
+
+#[test]
+fn over() {
+    expect_stack("1 2 over", &[int(1), int(2), int(1)]);
+}
+
+#[test]
+fn over_underflow() {
+    expect_error("1 over", "stack underflow");
+}
+
+#[test]
+fn rot() {
+    expect_stack("1 2 3 rot", &[int(2), int(3), int(1)]);
+}
+
+#[test]
+fn rot_underflow() {
+    expect_error("1 2 rot", "stack underflow");
+}
+
+#[test]
+fn nip() {
+    expect_stack("1 2 nip", &[int(2)]);
+}
+
+#[test]
+fn nip_underflow() {
+    expect_error("1 nip", "stack underflow");
+}
+
+#[test]
+fn tuck() {
+    expect_stack("1 2 tuck", &[int(2), int(1), int(2)]);
+}
+
+#[test]
+fn tuck_underflow() {
+    expect_error("1 tuck", "stack underflow");
+}
+
+#[test]
+fn stack_persists() {
+    let f = forth();
+    let ctx = default_ctx();
+    f.evaluate("1 2 3", &ctx).unwrap();
+    assert_eq!(f.stack(), vec![int(1), int(2), int(3)]);
+    f.evaluate("4 5", &ctx).unwrap();
+    assert_eq!(f.stack(), vec![int(1), int(2), int(3), int(4), int(5)]);
+}
+
+#[test]
+fn clear_stack() {
+    let f = forth();
+    f.evaluate("1 2 3", &default_ctx()).unwrap();
+    f.clear_stack();
+    assert!(f.stack().is_empty());
+}