superacli 1.1.6 → 1.1.7

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

@@ -1,441 +0,0 @@
-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

@@ -1,238 +0,0 @@
-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");
-}