test(eval): change eval tests base

tests/eval/basic.rs

@@ -1,20 +0,0 @@
-use crate::eval::eval_code;
-
-#[test]
-fn eval_print() {
-    assert_eq!(eval_code("print! 1").stdout, "1\n");
-    assert!(!eval_code("print 0").stderr.is_empty());
-    assert_eq!(eval_code("print! \"abc\"").stdout, "abc\n");
-    assert_eq!(eval_code("print! \"0.3\"").stdout, "0.3\n");
-    assert_eq!(eval_code("num = -3\nprint! num * 2").stdout, "-6\n");
-    assert_eq!(eval_code("print True").status.code().unwrap(), 1);
-}
-
-#[test]
-fn eval_assert() {
-    assert!(eval_code("assert True").status.success());
-    assert!(!eval_code("assert False").status.success());
-    assert_eq!(eval_code("assert 1").status.code().unwrap(), 0);
-    assert!(!eval_code("assert 0.2").status.success());
-    assert!(eval_code("flag = True\nassert flag").status.success());
-}

tests/eval/build_in_function.rs

@@ -0,0 +1,52 @@
+use crate::eval::{eval, successful_output};
+
+#[test]
+fn eval_print() {
+    assert_eq!(eval("print! 1"), successful_output("1\n"));
+    assert_eq!(eval("print! \"abc\""), successful_output("abc\n"));
+    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"));
+    assert_eq!(
+        eval(
+            r#"print! """A
+B""", "C", """
+D""""#
+        ),
+        successful_output("A\nB C \nD\n")
+    );
+    assert_eq!(eval("print!(\"a\")"), successful_output("a\n"));
+    assert_eq!(
+        eval("print! \"a\", \"b\", 3, end := \"\""),
+        successful_output("a b 3")
+    );
+
+    {
+        let output = eval("print 1");
+        assert_eq!(output.stdout, "");
+        assert!(!output.stderr.is_empty());
+        assert_eq!(output.status_code, Some(1));
+    }
+    assert_eq!(eval("num = -3\nprint! num * 2").stdout, "-6\n");
+}
+
+#[test]
+fn eval_assert() {
+    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));
+    }
+    assert_eq!(eval("assert 0.2").status_code, Some(1));
+    assert_eq!(eval("assert! True").status_code, Some(1));
+}

tests/eval/literal.rs

@@ -1,8 +1,79 @@
-use crate::eval::eval_code;
+use crate::eval::{eval, successful_output};
+
+#[test]
+fn eval_string() {
+    assert_eq!(
+        eval("assert \"abcdef\" == \"abcdef\""),
+        successful_output("")
+    );
+    assert_eq!(
+        eval("assert \"1234567890ABC\" == \"\\{1234567890}ABC\""),
+        successful_output("")
+    );
+    assert_eq!(eval("print! \"\""), successful_output("\n"));
+    assert_eq!(eval("assert \"\" == \"\""), successful_output(""));
+    assert_eq!(eval("print! \"A\""), successful_output("A\n"));
+    assert_eq!(
+        eval(r#"print! "    \{"b"}\{False} \{[1]}""#),
+        successful_output("    bFalse [1]\n")
+    );
+    assert_eq!(
+        eval(r#"print! "a\{"b"}c\{"d \{" e\{"f"}g\{-2+3}"}"}""#),
+        successful_output("abcd  efg1\n")
+    );
+    assert_eq!(
+        eval(
+            r#"print! """abc
+def
+  ghi
+j kl """"#
+        ),
+        successful_output("abc\ndef\n  ghi\nj kl \n")
+    );
+    assert_eq!(
+        eval(
+            r#"print! """
+  \{()}
+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));
+    }
+    assert_eq!(eval("print! \"\\\"").status_code, Some(1));
+}
 
 #[test]
 fn eval_int() {
-    assert!(eval_code("assert 100 == 100").status.success());
-    assert_eq!(eval_code("print! \"abc\"").stdout, "abc\n");
-    assert_eq!(eval_code("print! \"0.3\"").stdout, "0.3\n");
+    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));
+    }
+    assert_eq!(eval("assert 10 == 11").status_code, Some(1));
+}
+
+#[test]
+fn eval_ratio() {
+    assert_eq!(eval("print! 0.1234"), successful_output("0.1234\n"));
 }

tests/eval/mod.rs

@@ -1,16 +1,25 @@
 use erg_common::style::{colors::DEBUG_MAIN, RESET};
 use std::process::{Command, Stdio};
 
-mod basic;
+mod build_in_function;
 mod literal;
 
+#[derive(PartialEq, Debug)]
 pub(crate) struct CommandOutput {
     pub(crate) stdout: String,
     pub(crate) stderr: String,
-    pub(crate) status: std::process::ExitStatus,
+    pub(crate) status_code: Option<i32>,
 }
 
-pub(crate) fn eval_code(code: &'static str) -> CommandOutput {
+fn successful_output(stdout: &str) -> CommandOutput {
+    CommandOutput {
+        stdout: stdout.into(),
+        stderr: "".into(),
+        status_code: Some(0),
+    }
+}
+
+pub(crate) fn eval(code: &'static str) -> CommandOutput {
     println!("{DEBUG_MAIN}[test] eval:\n{code}{RESET}");
     let output = Command::new(env!(concat!("CARGO_BIN_EXE_", env!("CARGO_PKG_NAME"))))
         .args(["-c", code])
@@ -18,16 +27,16 @@ pub(crate) fn eval_code(code: &'static str) -> CommandOutput {
         .stdout(Stdio::piped())
         .stderr(Stdio::piped())
         .spawn()
-        .unwrap()
+        .expect("Failed to execute command")
         .wait_with_output()
-        .unwrap();
+        .expect("failed to wait for output");
     CommandOutput {
         stdout: String::from_utf8(output.stdout)
-            .unwrap()
+            .expect("failed to convert stdout to string")
             .replace("\r\n", "\n"),
         stderr: String::from_utf8(output.stderr)
-            .unwrap()
+            .expect("failed to convert stderr to string")
             .replace("\r\n", "\n"),
-        status: output.status,
+        status_code: output.status.code(),
     }
 }