Merge branch 'main' into improve-repl

tests/eval/build_in_function.rs

@@ -1,17 +1,44 @@
+//! for performance, 1 function per 1~2 test
+
 use crate::eval::{eval, successful_output};
 
 #[test]
-fn eval_print() {
+fn eval_print_1() {
     assert_eq!(eval("print! 1"), successful_output("1\n"));
+}
+
+#[test]
+fn eval_print_str() {
     assert_eq!(eval("print! \"abc\""), successful_output("abc\n"));
+    assert_eq!(eval("print!(\"a\")"), successful_output("a\n"));
+}
+
+#[test]
+fn eval_print_ratio() {
+    assert_eq!(eval("print! \"0.3\""), successful_output("0.3\n"));
+}
+
+#[test]
+fn eval_print_bool() {
+    assert_eq!(eval("print! True"), successful_output("True\n"));
+}
+
+#[test]
+fn eval_print_unit() {
+    assert_eq!(eval("print! (())"), successful_output("()\n"));
+}
+
+#[test]
+fn eval_interpolation() {
     assert_eq!(
         eval("world = \"world\"\nprint! \"hello \\{world}\""),
         successful_output("hello world\n")
     );
-    assert_eq!(eval("print! \"0.3\""), successful_output("0.3\n"));
-    assert_eq!(eval("print! True"), successful_output("True\n"));
-    assert_eq!(eval("print! (())"), successful_output("()\n"));
     assert_eq!(eval("print! \"\\{0.005}\""), successful_output("0.005\n"));
+}
+
+#[test]
+fn eval_multiline_str() {
     assert_eq!(
         eval(
             r#"print! """A
@@ -20,33 +47,58 @@ D""""#
         ),
         successful_output("A\nB C \nD\n")
     );
-    assert_eq!(eval("print!(\"a\")"), successful_output("a\n"));
+}
+
+#[test]
+fn eval_keyword_call() {
     assert_eq!(
         eval("print! \"a\", \"b\", 3, end := \"\""),
         successful_output("a b 3")
     );
+}
 
-    {
-        let output = eval("print 1"); // print! is correct
-        assert_eq!(output.stdout, "");
-        assert!(!output.stderr.is_empty());
-        assert_eq!(output.status_code, Some(1));
-    }
+#[test]
+fn eval_invalid_print() {
+    let output = eval("print 1"); // print! is correct
+    assert_eq!(output.stdout, "");
+    assert!(!output.stderr.is_empty());
+    assert_eq!(output.status_code, Some(1));
+}
+
+#[test]
+fn eval_assign_and_print() {
     assert_eq!(eval("num = -3\nprint! num * 2").stdout, "-6\n");
 }
 
 #[test]
-fn eval_assert() {
+fn eval_assert_true() {
     assert_eq!(eval("assert True"), successful_output(""));
-    assert_eq!(eval("assert 1"), successful_output(""));
-    assert_eq!(eval("flag = True\nassert flag"), successful_output(""));
+}
 
-    {
-        let output = eval("assert False");
-        assert_eq!(output.stdout, "");
-        assert!(!output.stderr.is_empty());
-        assert_eq!(output.status_code, Some(1));
-    }
+#[test]
+fn eval_assert_1() {
+    assert_eq!(eval("assert 1"), successful_output(""));
+}
+
+#[test]
+fn eval_assign_and_assert() {
+    assert_eq!(eval("flag = True\nassert flag"), successful_output(""));
+}
+
+#[test]
+fn eval_assert_false() {
+    let output = eval("assert False");
+    assert_eq!(output.stdout, "");
+    assert!(!output.stderr.is_empty());
+    assert_eq!(output.status_code, Some(1));
+}
+
+#[test]
+fn eval_assert_0point2() {
     assert_eq!(eval("assert 0.2").status_code, Some(1));
+}
+
+#[test]
+fn eval_invalid_assert() {
     assert_eq!(eval("assert! True").status_code, Some(1));
 }

tests/eval/literal.rs

@@ -1,30 +1,57 @@
 use crate::eval::{eval, successful_output};
 
 #[test]
-fn eval_string() {
+fn eval_assert_str() {
     assert_eq!(
         eval("assert \"abcdef\" == \"abcdef\""),
         successful_output("")
     );
+}
+
+#[test]
+fn eval_assert_interpolation() {
     assert_eq!(
         eval("assert \"1234567890ABC\" == \"\\{1234567890}ABC\""),
         successful_output("")
     );
+}
+
+#[test]
+fn eval_print_empty() {
     assert_eq!(eval("print! \"\""), successful_output("\n"));
+}
+
+#[test]
+fn eval_assert_empty() {
     assert_eq!(eval("assert \"\" == \"\""), successful_output(""));
-    assert_eq!(eval("print! \"A\""), successful_output("A\n"));
+}
+
+#[test]
+fn eval_assert_interpolation_2() {
     assert_eq!(
-        eval(r#"a = 10;print! "2 * 5 = \{a}""#),
-        successful_output("2 * 5 = 10\n")
+        eval(r#"a = 10;assert "\{2 * 5}" == "\{a}""#),
+        successful_output("")
     );
+}
+
+#[test]
+fn eval_interpolation() {
     assert_eq!(
         eval(r#"print! "    \{"b"}\{False} \{[1]}""#),
         successful_output("    bFalse [1]\n")
     );
+}
+
+#[test]
+fn eval_interpolation_2() {
     assert_eq!(
         eval(r#"print! "a\{"b"}c\{"d \{" e\{"f"}g\{-2+3}"}"}""#),
         successful_output("abcd  efg1\n")
     );
+}
+
+#[test]
+fn eval_multiline_string() {
     assert_eq!(
         eval(
             r#"print! """abc
@@ -34,6 +61,10 @@ j kl """"#
         ),
         successful_output("abc\ndef\n  ghi\nj kl \n")
     );
+}
+
+#[test]
+fn eval_multiline_string_interpolation() {
     assert_eq!(
         eval(
             r#"print! """
@@ -44,38 +75,64 @@ a
         successful_output("\n  ()\na\n\n")
     );
     // TODO: more diverse characters
+}
 
-    {
-        let output = eval("assert \"abcde\" == \"abcdef\"");
-        assert_eq!(output.stdout, "");
-        assert!(!output.stderr.is_empty());
-        assert_eq!(output.status_code, Some(1));
-    }
+#[test]
+fn eval_invalid_assertion() {
+    let output = eval("assert \"abcde\" == \"abcdef\"");
+    assert_eq!(output.stdout, "");
+    assert!(!output.stderr.is_empty());
+    assert_eq!(output.status_code, Some(1));
+}
+
+#[test]
+fn eval_invalid_closing_string() {
     assert_eq!(eval("print! \"\\\"").status_code, Some(1));
 }
 
 #[test]
-fn eval_int() {
+fn eval_assert_99() {
     assert_eq!(eval("assert 99 == 99"), successful_output(""));
-    assert_eq!(eval("print! 256"), successful_output("256\n"));
-    // assert_eq!(eval_code("assert -2 == -2"), success_output("")); // failed
-    assert_eq!(eval("print! 0"), successful_output("0\n"));
-    // assert_eq!(eval_code("print! -1000"), success_output("-1000\n")); // failed
-    assert_eq!(eval("print! 0 == 0"), successful_output("True\n"));
-    assert_eq!(eval("print! 2147483647"), successful_output("2147483647\n"));
-    // assert_eq!(eval("print! 2147483648"), successful_output("2147483648\n")); // should be ok?
-    assert_eq!(
-        eval("print!(-2147483648)"),
-        successful_output("-2147483648\n")
-    );
-    // assert_eq!(eval("print!(-2147483649)"), successful_output("-2147483649\n")); // should be ok?
+}
 
-    {
-        let result = eval("assert 100 == 1000");
-        assert_eq!(result.stdout, "");
-        assert!(!result.stderr.is_empty());
-        assert_eq!(result.status_code, Some(1));
-    }
+#[test]
+fn eval_assert_minus2() {
+    assert_eq!(eval("assert -2 == -2"), successful_output(""));
+}
+
+#[test]
+fn eval_minus1000() {
+    assert_eq!(eval("print! -1000"), successful_output("-1000\n"));
+}
+
+#[test]
+fn eval_0_eq_0() {
+    assert_eq!(eval("print! 0 == 0"), successful_output("True\n"));
+}
+
+// TODO: support big numbers
+/*
+#[test]
+fn eval_bignum() {
+    assert_eq!(eval("print! 214748364778473683657867814876187416"), successful_output("214748364778473683657867814876187416\n"));
+}
+
+#[test]
+fn eval_neg_bignum() {
+    assert_eq!(eval("print!(-214748364778473683657867814876187416)"), successful_output("-214748364778473683657867814876187416\n"));
+}
+*/
+
+#[test]
+fn eval_assert_inequality() {
+    let result = eval("assert 100 == 1000");
+    assert_eq!(result.stdout, "");
+    assert!(!result.stderr.is_empty());
+    assert_eq!(result.status_code, Some(1));
+}
+
+#[test]
+fn eval_assert_inequality_2() {
     assert_eq!(eval("assert 10 == 11").status_code, Some(1));
 }