superacli 1.1.4 → 1.1.6

package/ref-monty/crates/monty/tests/parse_errors.rs

@@ -0,0 +1,441 @@
+use std::fmt::Write;
+
+use monty::{ExcType, MontyException, MontyRun};
+
+/// Helper to extract the exception type from a parse error.
+fn get_exc_type(result: Result<MontyRun, MontyException>) -> ExcType {
+    let err = result.expect_err("expected parse error");
+    err.exc_type()
+}
+
+#[test]
+fn complex_numbers_return_not_implemented_error() {
+    let result = MontyRun::new("1 + 2j".to_owned(), "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::NotImplementedError);
+}
+
+#[test]
+fn complex_numbers_have_descriptive_message() {
+    let result = MontyRun::new("1 + 2j".to_owned(), "test.py", vec![]);
+    let exc = result.expect_err("expected parse error");
+    assert!(
+        exc.message().is_some_and(|m| m.contains("complex")),
+        "message should mention 'complex', got: {exc}"
+    );
+}
+
+#[test]
+fn yield_expressions_return_not_implemented_error() {
+    // Yield expressions are not supported and fail at parse time
+    let result = MontyRun::new("def foo():\n    yield 1".to_owned(), "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::NotImplementedError);
+    let result = MontyRun::new("def foo():\n    yield 1".to_owned(), "test.py", vec![]);
+    let exc = result.expect_err("expected parse error");
+    assert!(
+        exc.message().is_some_and(|m| m.contains("yield")),
+        "message should mention 'yield', got: {exc}"
+    );
+}
+
+#[test]
+fn classes_return_not_implemented_error() {
+    let result = MontyRun::new("class Foo: pass".to_owned(), "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::NotImplementedError);
+}
+
+#[test]
+fn unknown_imports_compile_successfully_error_deferred_to_runtime() {
+    // Unknown modules (not sys, typing, os, etc.) compile successfully.
+    // The ModuleNotFoundError is deferred to runtime, allowing TYPE_CHECKING
+    // imports to work without causing compile-time errors.
+    let result = MontyRun::new("import foobar".to_owned(), "test.py", vec![]);
+    assert!(result.is_ok(), "unknown import should compile successfully");
+}
+
+#[test]
+fn with_statement_returns_not_implemented_error() {
+    let result = MontyRun::new("with open('f') as f: pass".to_owned(), "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::NotImplementedError);
+}
+
+#[test]
+fn error_display_format() {
+    // Verify the Display format matches Python's exception output with traceback
+    let result = MontyRun::new("1 + 2j".to_owned(), "test.py", vec![]);
+    let err = result.expect_err("expected parse error");
+    let display = err.to_string();
+    // Should start with traceback header
+    assert!(
+        display.starts_with("Traceback (most recent call last):"),
+        "display should start with 'Traceback': got: {display}"
+    );
+    // Should contain the file/line info
+    assert!(
+        display.contains("File \"test.py\", line 1"),
+        "display should contain file location, got: {display}"
+    );
+    // Should end with NotImplementedError message
+    assert!(
+        display.contains("NotImplementedError:"),
+        "display should contain 'NotImplementedError:', got: {display}"
+    );
+    assert!(
+        display.contains("monty syntax parser"),
+        "display should mention 'monty syntax parser', got: {display}"
+    );
+}
+
+/// Tests that syntax errors return `SyntaxError` exceptions.
+
+#[test]
+fn invalid_fstring_format_spec_returns_syntax_error() {
+    let result = MontyRun::new("f'{1:10xyz}'".to_owned(), "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn invalid_fstring_format_spec_str_returns_syntax_error() {
+    let result = MontyRun::new("f'{\"hello\":abc}'".to_owned(), "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn syntax_error_display_format() {
+    let result = MontyRun::new("f'{1:10xyz}'".to_owned(), "test.py", vec![]);
+    let err = result.expect_err("expected parse error");
+    let display = err.to_string();
+    assert!(
+        display.contains("SyntaxError:"),
+        "display should contain 'SyntaxError:', got: {display}"
+    );
+}
+
+#[test]
+fn deeply_nested_tuples_exceed_limit() {
+    // Build nested tuple like ((((x,),),),) with depth > 200
+    let mut code = "x".to_string();
+    for _ in 0..250 {
+        code = format!("({code},)");
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    let err = result.expect_err("expected parse error");
+    assert_eq!(err.exc_type(), ExcType::SyntaxError);
+    assert_eq!(
+        err.message(),
+        Some("too many nested parentheses"),
+        "error message should match CPython, got: {:?}",
+        err.message()
+    );
+}
+
+#[test]
+fn nested_tuples_within_limit_succeed() {
+    // Build nested tuple with depth = 20, which is well under the 200 limit.
+    // We use a small value because the ruff parser uses significant stack
+    // space per nesting level in debug builds.
+    let mut code = "x".to_string();
+    for _ in 0..20 {
+        code = format!("({code},)");
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert!(result.is_ok(), "nesting within limit should succeed");
+}
+
+#[test]
+fn deeply_nested_unpack_assignment_exceeds_limit() {
+    // Build nested unpack assignment like ((((x,),),),) = value with depth > 200
+    let mut target = "x".to_string();
+    for _ in 0..250 {
+        target = format!("({target},)");
+    }
+    let code = format!("{target} = (1,)");
+    let result = MontyRun::new(code, "test.py", vec![]);
+    let err = result.expect_err("expected parse error");
+    assert_eq!(err.exc_type(), ExcType::SyntaxError);
+    assert_eq!(
+        err.message(),
+        Some("too many nested parentheses"),
+        "error message should match CPython, got: {:?}",
+        err.message()
+    );
+}
+
+#[test]
+fn deeply_nested_lists_exceed_limit() {
+    // Build nested list like [[[[[x]]]]]
+    let mut code = "x".to_string();
+    for _ in 0..250 {
+        code = format!("[{code}]");
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_dicts_exceed_limit() {
+    // Build nested dict like {'a': {'a': {'a': ...}}}
+    let mut code = "1".to_string();
+    for _ in 0..250 {
+        code = format!("{{'a': {code}}}");
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_function_calls_exceed_limit() {
+    // Build nested calls like f(f(f(f(x))))
+    let mut code = "x".to_string();
+    for _ in 0..250 {
+        code = format!("f({code})");
+    }
+    let code = format!("def f(x): return x\n{code}");
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_binary_ops_exceed_limit() {
+    // Build nested binary ops like ((((x + 1) + 1) + 1) + 1)
+    let mut code = "x".to_string();
+    for _ in 0..250 {
+        code = format!("({code} + 1)");
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_ternary_if_exceed_limit() {
+    // Build nested ternary like (1 if (1 if (1 if ... else 0) else 0) else 0)
+    let mut code = "x".to_string();
+    for _ in 0..250 {
+        code = format!("(1 if {code} else 0)");
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_subscripts_exceed_limit() {
+    // Build nested subscripts like a[b[c[d[...]]]]
+    let mut code = "0".to_string();
+    for _ in 0..250 {
+        code = format!("a[{code}]");
+    }
+    let code = format!("a = [1]\n{code}");
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_list_comprehension_exceed_limit() {
+    // Build nested list comprehension like [x for x in [y for y in [...]]]
+    let mut code = "[1]".to_string();
+    for _ in 0..250 {
+        code = format!("[x for x in {code}]");
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_if_statements_exceed_limit() {
+    // Build nested if statements
+    let mut code = "x = 1\n".to_string();
+    for i in 0..250 {
+        let indent = "    ".repeat(i);
+        writeln!(code, "{indent}if 1:").unwrap();
+    }
+    write!(code, "{}pass", "    ".repeat(250)).unwrap();
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_while_loops_exceed_limit() {
+    // Build nested while loops
+    let mut code = String::new();
+    for i in 0..250 {
+        let indent = "    ".repeat(i);
+        writeln!(code, "{indent}while True:").unwrap();
+    }
+    write!(code, "{}break", "    ".repeat(250)).unwrap();
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_for_loops_exceed_limit() {
+    // Build nested for loops
+    let mut code = String::new();
+    for i in 0..250 {
+        let indent = "    ".repeat(i);
+        writeln!(code, "{indent}for x in [1]:").unwrap();
+    }
+    write!(code, "{}pass", "    ".repeat(250)).unwrap();
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_try_except_exceed_limit() {
+    // Build nested try/except blocks
+    let mut code = String::new();
+    for i in 0..250 {
+        let indent = "    ".repeat(i);
+        writeln!(code, "{indent}try:").unwrap();
+    }
+    writeln!(code, "{}pass", "    ".repeat(250)).unwrap();
+    for i in (0..250).rev() {
+        let indent = "    ".repeat(i);
+        writeln!(code, "{indent}except: pass").unwrap();
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_function_defs_exceed_limit() {
+    // Build nested function definitions
+    let mut code = String::new();
+    for i in 0..250 {
+        let indent = "    ".repeat(i);
+        writeln!(code, "{indent}def f():").unwrap();
+    }
+    write!(code, "{}pass", "    ".repeat(250)).unwrap();
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_attribute_access_exceed_limit() {
+    // Build chained attribute access like a.b.c.d.e...
+    let mut code = "a".to_string();
+    for _ in 0..250 {
+        code.push_str(".x");
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_lambdas_exceed_limit() {
+    // Build nested lambdas like (lambda: (lambda: (lambda: ... x)))
+    let mut code = "x".to_string();
+    for _ in 0..250 {
+        code = format!("(lambda: {code})");
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_unary_not_exceed_limit() {
+    // Build nested not operators like not (not (not ... True))
+    let mut code = "True".to_string();
+    for _ in 0..250 {
+        code = format!("not ({code})");
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_unary_minus_exceed_limit() {
+    // Build nested unary minus like -(-(-... 1))
+    let mut code = "1".to_string();
+    for _ in 0..250 {
+        code = format!("-({code})");
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_walrus_operator_exceed_limit() {
+    // Build nested walrus operators like (a := (b := (c := ... 1)))
+    let mut code = "1".to_string();
+    for i in 0..250 {
+        code = format!("(x{i} := {code})");
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_await_exceed_limit() {
+    // Build nested await like await (await (await ... x))
+    // We need this in an async function context
+    let mut code = "x".to_string();
+    for _ in 0..250 {
+        code = format!("await ({code})");
+    }
+    let code = format!("async def f():\n    {code}");
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_boolean_and_exceed_limit() {
+    // Build nested boolean and like (True and (True and (True and ...)))
+    let mut code = "True".to_string();
+    for _ in 0..250 {
+        code = format!("(True and {code})");
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn deeply_nested_boolean_or_exceed_limit() {
+    // Build nested boolean or like (False or (False or (False or ...)))
+    let mut code = "True".to_string();
+    for _ in 0..250 {
+        code = format!("(False or {code})");
+    }
+    let result = MontyRun::new(code, "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+// === Runtime NotImplementedError tests ===
+// These test that unimplemented features return proper errors instead of panicking.
+
+/// Helper to run code and get the exception type from a runtime error.
+fn run_and_get_exc_type(code: &str) -> ExcType {
+    let runner = MontyRun::new(code.to_owned(), "test.py", vec![]).expect("should parse");
+    let err = runner.run_no_limits(vec![]).expect_err("expected runtime error");
+    err.exc_type()
+}
+
+#[test]
+fn matrix_multiplication_returns_not_implemented_error() {
+    // The @ operator (matrix multiplication) is not supported at runtime
+    assert_eq!(run_and_get_exc_type("1 @ 2"), ExcType::NotImplementedError);
+}
+
+#[test]
+fn matrix_multiplication_augmented_assignment_returns_syntax_error() {
+    // The @= operator (augmented matrix multiplication) is not supported at compile time
+    let result = MontyRun::new("a = 1\na @= 2".to_owned(), "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::SyntaxError);
+}
+
+#[test]
+fn matrix_multiplication_augmented_assignment_has_descriptive_message() {
+    // Verify the error message is helpful
+    let result = MontyRun::new("a = 1\na @= 2".to_owned(), "test.py", vec![]);
+    let exc = result.expect_err("expected compile error");
+    assert!(
+        exc.message().is_some_and(|m| m.contains("@=")),
+        "message should mention '@=', got: {:?}",
+        exc.message()
+    );
+}
+
+#[test]
+fn del_statement_returns_not_implemented_error() {
+    // The del statement is not supported at parse time
+    let result = MontyRun::new("x = 1\ndel x".to_owned(), "test.py", vec![]);
+    assert_eq!(get_exc_type(result), ExcType::NotImplementedError);
+}

package/ref-monty/crates/monty/tests/print_writer.rs

@@ -0,0 +1,238 @@
+use monty::{MontyRun, NoLimitTracker, PrintWriter};
+
+#[test]
+fn print_single_string() {
+    let ex = MontyRun::new("print('hello')".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "hello\n");
+}
+
+#[test]
+fn print_multiple_args() {
+    let ex = MontyRun::new("print('hello', 'world')".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "hello world\n");
+}
+
+#[test]
+fn print_multiple_statements() {
+    let ex = MontyRun::new(
+        "print('one')\nprint('two')\nprint('three')".to_owned(),
+        "test.py",
+        vec![],
+    )
+    .unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "one\ntwo\nthree\n");
+}
+
+#[test]
+fn print_empty() {
+    let ex = MontyRun::new("print()".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "\n");
+}
+
+#[test]
+fn print_integers() {
+    let ex = MontyRun::new("print(1, 2, 3)".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "1 2 3\n");
+}
+
+#[test]
+fn print_mixed_types() {
+    let ex = MontyRun::new("print('count:', 42, True)".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "count: 42 True\n");
+}
+
+#[test]
+fn print_in_function() {
+    let code = "
+def greet(name):
+    print('Hello', name)
+
+greet('Alice')
+greet('Bob')
+";
+    let ex = MontyRun::new(code.to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "Hello Alice\nHello Bob\n");
+}
+
+#[test]
+fn print_in_loop() {
+    let code = "
+for i in range(3):
+    print(i)
+";
+    let ex = MontyRun::new(code.to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "0\n1\n2\n");
+}
+
+#[test]
+fn collect_output_accessible_after_run() {
+    let ex = MontyRun::new("print('test')".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "test\n");
+}
+
+#[test]
+fn writer_reuse_accumulates() {
+    let mut output = String::new();
+
+    let ex1 = MontyRun::new("print('first')".to_owned(), "test.py", vec![]).unwrap();
+    ex1.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+
+    let ex2 = MontyRun::new("print('second')".to_owned(), "test.py", vec![]).unwrap();
+    ex2.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+
+    assert_eq!(output, "first\nsecond\n");
+}
+
+#[test]
+fn disabled_suppresses_output() {
+    let code = "
+for i in range(100):
+    print('this should be suppressed', i)
+";
+    let ex = MontyRun::new(code.to_owned(), "test.py", vec![]).unwrap();
+    // Should complete without error, output is silently discarded
+    let result = ex.run(vec![], NoLimitTracker, PrintWriter::Disabled);
+    assert!(result.is_ok());
+}
+
+// === print() kwargs tests ===
+
+#[test]
+fn print_custom_sep() {
+    let ex = MontyRun::new("print('a', 'b', 'c', sep='-')".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "a-b-c\n");
+}
+
+#[test]
+fn print_custom_end() {
+    let ex = MontyRun::new("print('hello', end='!')".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "hello!");
+}
+
+#[test]
+fn print_custom_sep_and_end() {
+    let ex = MontyRun::new(
+        "print('x', 'y', 'z', sep=', ', end='\\n---\\n')".to_owned(),
+        "test.py",
+        vec![],
+    )
+    .unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "x, y, z\n---\n");
+}
+
+#[test]
+fn print_empty_sep() {
+    let ex = MontyRun::new("print('a', 'b', 'c', sep='')".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "abc\n");
+}
+
+#[test]
+fn print_empty_end() {
+    let code = "print('first', end='')\nprint('second')";
+    let ex = MontyRun::new(code.to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "firstsecond\n");
+}
+
+#[test]
+fn print_sep_none() {
+    // sep=None should use default space
+    let ex = MontyRun::new("print('a', 'b', sep=None)".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    // In Python, sep=None means use default, but we treat it as empty string for simplicity
+    // This matches: print('a', 'b', sep=None) outputs "ab\n" with our impl
+    assert_eq!(output, "a b\n");
+}
+
+#[test]
+fn print_end_none() {
+    // end=None should use empty string (our interpretation)
+    let ex = MontyRun::new("print('hello', end=None)".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "hello\n");
+}
+
+#[test]
+fn print_flush_ignored() {
+    // flush=True should be accepted but ignored
+    let ex = MontyRun::new("print('test', flush=True)".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "test\n");
+}
+
+#[test]
+fn print_kwargs_dict() {
+    // Use a dict literal instead of dict() since dict builtin is not implemented
+    let ex = MontyRun::new("print('a', 'b', **{'sep': '-'})".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "a-b\n");
+}
+
+#[test]
+fn print_only_kwargs_no_args() {
+    let ex = MontyRun::new("print(sep='-', end='!')".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "!");
+}
+
+#[test]
+fn print_multiline_sep() {
+    let ex = MontyRun::new("print(1, 2, 3, sep='\\n')".to_owned(), "test.py", vec![]).unwrap();
+    let mut output = String::new();
+    ex.run(vec![], NoLimitTracker, PrintWriter::Collect(&mut output))
+        .unwrap();
+    assert_eq!(output, "1\n2\n3\n");
+}