superacli 1.1.6 → 1.1.7

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

@@ -1,420 +0,0 @@
-//! Tests for passing input values to the executor.
-//!
-//! These tests verify that `MontyObject` inputs are correctly converted to `Object`
-//! and can be used in Python code execution.
-
-use indexmap::IndexMap;
-use monty::{ExcType, MontyObject, MontyRun};
-
-// === Immediate Value Tests ===
-
-#[test]
-fn input_int() {
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex.run_no_limits(vec![MontyObject::Int(42)]).unwrap();
-    assert_eq!(result, MontyObject::Int(42));
-}
-
-#[test]
-fn input_int_arithmetic() {
-    let ex = MontyRun::new("x + 1".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex.run_no_limits(vec![MontyObject::Int(41)]).unwrap();
-    assert_eq!(result, MontyObject::Int(42));
-}
-
-#[test]
-fn input_bool_true() {
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex.run_no_limits(vec![MontyObject::Bool(true)]).unwrap();
-    assert_eq!(result, MontyObject::Bool(true));
-}
-
-#[test]
-fn input_bool_false() {
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex.run_no_limits(vec![MontyObject::Bool(false)]).unwrap();
-    assert_eq!(result, MontyObject::Bool(false));
-}
-
-#[test]
-fn input_float() {
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex.run_no_limits(vec![MontyObject::Float(2.5)]).unwrap();
-    assert_eq!(result, MontyObject::Float(2.5));
-}
-
-#[test]
-fn input_none() {
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex.run_no_limits(vec![MontyObject::None]).unwrap();
-    assert_eq!(result, MontyObject::None);
-}
-
-#[test]
-fn input_ellipsis() {
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex.run_no_limits(vec![MontyObject::Ellipsis]).unwrap();
-    assert_eq!(result, MontyObject::Ellipsis);
-}
-
-// === Heap-Allocated Value Tests ===
-
-#[test]
-fn input_string() {
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex
-        .run_no_limits(vec![MontyObject::String("hello".to_string())])
-        .unwrap();
-    assert_eq!(result, MontyObject::String("hello".to_string()));
-}
-
-#[test]
-fn input_string_concat() {
-    let ex = MontyRun::new("x + ' world'".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex
-        .run_no_limits(vec![MontyObject::String("hello".to_string())])
-        .unwrap();
-    assert_eq!(result, MontyObject::String("hello world".to_string()));
-}
-
-#[test]
-fn input_bytes() {
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex.run_no_limits(vec![MontyObject::Bytes(vec![1, 2, 3])]).unwrap();
-    assert_eq!(result, MontyObject::Bytes(vec![1, 2, 3]));
-}
-
-#[test]
-fn input_list() {
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex
-        .run_no_limits(vec![MontyObject::List(vec![MontyObject::Int(1), MontyObject::Int(2)])])
-        .unwrap();
-    assert_eq!(
-        result,
-        MontyObject::List(vec![MontyObject::Int(1), MontyObject::Int(2)])
-    );
-}
-
-#[test]
-fn input_list_append() {
-    let ex = MontyRun::new("x.append(3)\nx".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex
-        .run_no_limits(vec![MontyObject::List(vec![MontyObject::Int(1), MontyObject::Int(2)])])
-        .unwrap();
-    assert_eq!(
-        result,
-        MontyObject::List(vec![MontyObject::Int(1), MontyObject::Int(2), MontyObject::Int(3)])
-    );
-}
-
-#[test]
-fn input_tuple() {
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex
-        .run_no_limits(vec![MontyObject::Tuple(vec![
-            MontyObject::Int(1),
-            MontyObject::String("two".to_string()),
-        ])])
-        .unwrap();
-    assert_eq!(
-        result,
-        MontyObject::Tuple(vec![MontyObject::Int(1), MontyObject::String("two".to_string())])
-    );
-}
-
-#[test]
-fn input_dict() {
-    let mut map = IndexMap::new();
-    map.insert(MontyObject::String("a".to_string()), MontyObject::Int(1));
-
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex.run_no_limits(vec![MontyObject::dict(map)]).unwrap();
-
-    // Build expected map for comparison
-    let mut expected = IndexMap::new();
-    expected.insert(MontyObject::String("a".to_string()), MontyObject::Int(1));
-    assert_eq!(result, MontyObject::Dict(expected.into()));
-}
-
-#[test]
-fn input_dict_get() {
-    let mut map = IndexMap::new();
-    map.insert(MontyObject::String("key".to_string()), MontyObject::Int(42));
-
-    let ex = MontyRun::new("x['key']".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex.run_no_limits(vec![MontyObject::dict(map)]).unwrap();
-    assert_eq!(result, MontyObject::Int(42));
-}
-
-// === Multiple Inputs ===
-
-#[test]
-fn multiple_inputs_two() {
-    let ex = MontyRun::new("x + y".to_owned(), "test.py", vec!["x".to_owned(), "y".to_owned()]).unwrap();
-    let result = ex
-        .run_no_limits(vec![MontyObject::Int(10), MontyObject::Int(32)])
-        .unwrap();
-    assert_eq!(result, MontyObject::Int(42));
-}
-
-#[test]
-fn multiple_inputs_three() {
-    let ex = MontyRun::new(
-        "x + y + z".to_owned(),
-        "test.py",
-        vec!["x".to_owned(), "y".to_owned(), "z".to_owned()],
-    )
-    .unwrap();
-    let result = ex
-        .run_no_limits(vec![MontyObject::Int(10), MontyObject::Int(20), MontyObject::Int(12)])
-        .unwrap();
-    assert_eq!(result, MontyObject::Int(42));
-}
-
-#[test]
-fn multiple_inputs_mixed_types() {
-    // Create a list from two inputs
-    let ex = MontyRun::new("[x, y]".to_owned(), "test.py", vec!["x".to_owned(), "y".to_owned()]).unwrap();
-    let result = ex
-        .run_no_limits(vec![MontyObject::Int(1), MontyObject::String("two".to_string())])
-        .unwrap();
-    assert_eq!(
-        result,
-        MontyObject::List(vec![MontyObject::Int(1), MontyObject::String("two".to_string())])
-    );
-}
-
-// === Edge Cases ===
-
-#[test]
-fn no_inputs() {
-    let ex = MontyRun::new("42".to_owned(), "test.py", vec![]).unwrap();
-    let result = ex.run_no_limits(vec![]).unwrap();
-    assert_eq!(result, MontyObject::Int(42));
-}
-
-#[test]
-fn nested_list() {
-    let ex = MontyRun::new("x[0][1]".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex
-        .run_no_limits(vec![MontyObject::List(vec![MontyObject::List(vec![
-            MontyObject::Int(1),
-            MontyObject::Int(2),
-        ])])])
-        .unwrap();
-    assert_eq!(result, MontyObject::Int(2));
-}
-
-#[test]
-fn empty_list_input() {
-    let ex = MontyRun::new("len(x)".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex.run_no_limits(vec![MontyObject::List(vec![])]).unwrap();
-    assert_eq!(result, MontyObject::Int(0));
-}
-
-#[test]
-fn empty_string_input() {
-    let ex = MontyRun::new("len(x)".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex.run_no_limits(vec![MontyObject::String(String::new())]).unwrap();
-    assert_eq!(result, MontyObject::Int(0));
-}
-
-// === Exception Input Tests ===
-
-#[test]
-fn input_exception() {
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex
-        .run_no_limits(vec![MontyObject::Exception {
-            exc_type: ExcType::ValueError,
-            arg: Some("test message".to_string()),
-        }])
-        .unwrap();
-    assert_eq!(
-        result,
-        MontyObject::Exception {
-            exc_type: ExcType::ValueError,
-            arg: Some("test message".to_string()),
-        }
-    );
-}
-
-#[test]
-fn input_exception_no_arg() {
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex
-        .run_no_limits(vec![MontyObject::Exception {
-            exc_type: ExcType::TypeError,
-            arg: None,
-        }])
-        .unwrap();
-    assert_eq!(
-        result,
-        MontyObject::Exception {
-            exc_type: ExcType::TypeError,
-            arg: None,
-        }
-    );
-}
-
-#[test]
-fn input_exception_in_list() {
-    let ex = MontyRun::new("x[0]".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex
-        .run_no_limits(vec![MontyObject::List(vec![MontyObject::Exception {
-            exc_type: ExcType::KeyError,
-            arg: Some("key".to_string()),
-        }])])
-        .unwrap();
-    assert_eq!(
-        result,
-        MontyObject::Exception {
-            exc_type: ExcType::KeyError,
-            arg: Some("key".to_string()),
-        }
-    );
-}
-
-#[test]
-fn input_exception_raise() {
-    // Test that an exception passed as input can be raised
-    let ex = MontyRun::new("raise x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex.run_no_limits(vec![MontyObject::Exception {
-        exc_type: ExcType::ValueError,
-        arg: Some("input error".to_string()),
-    }]);
-    let exc = result.unwrap_err();
-    assert_eq!(exc.exc_type(), ExcType::ValueError);
-    assert_eq!(exc.message(), Some("input error"));
-}
-
-// === Invalid Input Tests ===
-
-#[test]
-fn invalid_input_repr() {
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    let result = ex.run_no_limits(vec![MontyObject::Repr("some repr".to_string())]);
-    assert!(result.is_err(), "Repr should not be a valid input");
-}
-
-#[test]
-fn invalid_input_repr_nested_in_list() {
-    let ex = MontyRun::new("x".to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    // Repr nested inside a list should still be invalid
-    let result = ex.run_no_limits(vec![MontyObject::List(vec![MontyObject::Repr(
-        "nested repr".to_string(),
-    )])]);
-    assert!(result.is_err(), "Repr nested in list should be invalid");
-}
-
-// === Function Parameter Shadowing Tests ===
-// These tests verify that function parameters properly shadow script inputs with the same name.
-
-#[test]
-fn function_param_shadows_input() {
-    // Function parameter `x` should shadow the script input `x`
-    let code = "
-def foo(x):
-    return x + 1
-
-foo(x * 2)
-";
-    let ex = MontyRun::new(code.to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    // x=5 (input), foo(x * 2) = foo(10), inside foo x=10 (param), returns 11
-    let result = ex.run_no_limits(vec![MontyObject::Int(5)]).unwrap();
-    assert_eq!(result, MontyObject::Int(11));
-}
-
-#[test]
-fn function_param_shadows_input_multiple_params() {
-    // Multiple function parameters should all shadow their corresponding inputs
-    let code = "
-def add(x, y):
-    return x + y
-
-add(x * 10, y * 100)
-";
-    let ex = MontyRun::new(code.to_owned(), "test.py", vec!["x".to_owned(), "y".to_owned()]).unwrap();
-    // x=2, y=3 (inputs), add(20, 300), inside add x=20, y=300, returns 320
-    let result = ex
-        .run_no_limits(vec![MontyObject::Int(2), MontyObject::Int(3)])
-        .unwrap();
-    assert_eq!(result, MontyObject::Int(320));
-}
-
-#[test]
-fn function_param_shadows_input_but_global_accessible() {
-    // Function parameter shadows input, but other inputs are still accessible as globals
-    let code = "
-def foo(x):
-    return x + y
-
-foo(100)
-";
-    let ex = MontyRun::new(code.to_owned(), "test.py", vec!["x".to_owned(), "y".to_owned()]).unwrap();
-    // x=5, y=3 (inputs), foo(100), inside foo x=100 (param), y=3 (global), returns 103
-    let result = ex
-        .run_no_limits(vec![MontyObject::Int(5), MontyObject::Int(3)])
-        .unwrap();
-    assert_eq!(result, MontyObject::Int(103));
-}
-
-#[test]
-fn function_param_shadows_input_accessible_outside() {
-    // Script input should still be accessible outside the function that shadows it
-    let code = "
-def double(x):
-    return x * 2
-
-double(10) + x
-";
-    let ex = MontyRun::new(code.to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    // x=5 (input), double(10) = 20, then 20 + x (global) = 20 + 5 = 25
-    let result = ex.run_no_limits(vec![MontyObject::Int(5)]).unwrap();
-    assert_eq!(result, MontyObject::Int(25));
-}
-
-#[test]
-fn function_param_with_default_shadows_input() {
-    // Function parameter with default should shadow input when called with argument
-    let code = "
-def foo(x=100):
-    return x + 1
-
-foo(x * 2)
-";
-    let ex = MontyRun::new(code.to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    // x=5 (input), foo(10), inside foo x=10 (param), returns 11
-    let result = ex.run_no_limits(vec![MontyObject::Int(5)]).unwrap();
-    assert_eq!(result, MontyObject::Int(11));
-}
-
-#[test]
-fn function_uses_input_as_argument() {
-    // Input can be passed as argument, and param shadows inside function
-    let code = "
-def double(x):
-    return x * 2
-
-double(x)
-";
-    let ex = MontyRun::new(code.to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    // x=7 (input), double(7), inside double x=7 (param from arg), returns 14
-    let result = ex.run_no_limits(vec![MontyObject::Int(7)]).unwrap();
-    assert_eq!(result, MontyObject::Int(14));
-}
-
-#[test]
-fn function_doesnt_uses_input_as_argument() {
-    let code = "
-def double(x):
-    return x * 2
-
-double(2)
-";
-    let ex = MontyRun::new(code.to_owned(), "test.py", vec!["x".to_owned()]).unwrap();
-    // x=7 (input), double(7), inside double x=7 (param from arg), returns 14
-    let result = ex.run_no_limits(vec![MontyObject::Int(7)]).unwrap();
-    assert_eq!(result, MontyObject::Int(4));
-}

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

@@ -1,250 +0,0 @@
-//! Tests for JSON serialization and deserialization of `MontyObject`.
-//!
-//! `MontyObject` uses derived serde with externally tagged enum format.
-//! This means each variant is wrapped in an object with the variant name as key.
-
-use monty::{ExcType, MontyObject, MontyRun};
-
-// === JSON Serialization Tests ===
-
-#[test]
-fn json_output_primitives() {
-    // Primitives are wrapped in their variant names
-    assert_eq!(serde_json::to_string(&MontyObject::Int(42)).unwrap(), r#"{"Int":42}"#);
-    assert_eq!(
-        serde_json::to_string(&MontyObject::Float(1.5)).unwrap(),
-        r#"{"Float":1.5}"#
-    );
-    assert_eq!(
-        serde_json::to_string(&MontyObject::String("hi".into())).unwrap(),
-        r#"{"String":"hi"}"#
-    );
-    assert_eq!(
-        serde_json::to_string(&MontyObject::Bool(true)).unwrap(),
-        r#"{"Bool":true}"#
-    );
-    assert_eq!(serde_json::to_string(&MontyObject::None).unwrap(), r#""None""#);
-}
-
-#[test]
-fn json_output_list() {
-    let ex = MontyRun::new("[1, 'two', 3.0]".to_owned(), "test.py", vec![]).unwrap();
-    let result = ex.run_no_limits(vec![]).unwrap();
-    assert_eq!(
-        serde_json::to_string(&result).unwrap(),
-        r#"{"List":[{"Int":1},{"String":"two"},{"Float":3.0}]}"#
-    );
-}
-
-#[test]
-fn json_output_dict() {
-    let ex = MontyRun::new("{'a': 1, 'b': 2}".to_owned(), "test.py", vec![]).unwrap();
-    let result = ex.run_no_limits(vec![]).unwrap();
-    assert_eq!(
-        serde_json::to_string(&result).unwrap(),
-        r#"{"Dict":[[{"String":"a"},{"Int":1}],[{"String":"b"},{"Int":2}]]}"#
-    );
-}
-
-#[test]
-fn json_output_tuple() {
-    let ex = MontyRun::new("(1, 'two')".to_owned(), "test.py", vec![]).unwrap();
-    let result = ex.run_no_limits(vec![]).unwrap();
-    assert_eq!(
-        serde_json::to_string(&result).unwrap(),
-        r#"{"Tuple":[{"Int":1},{"String":"two"}]}"#
-    );
-}
-
-#[test]
-fn json_output_bytes() {
-    let ex = MontyRun::new("b'hi'".to_owned(), "test.py", vec![]).unwrap();
-    let result = ex.run_no_limits(vec![]).unwrap();
-    assert_eq!(serde_json::to_string(&result).unwrap(), r#"{"Bytes":[104,105]}"#);
-}
-
-#[test]
-fn json_output_ellipsis() {
-    let ex = MontyRun::new("...".to_owned(), "test.py", vec![]).unwrap();
-    let result = ex.run_no_limits(vec![]).unwrap();
-    assert_eq!(serde_json::to_string(&result).unwrap(), r#""Ellipsis""#);
-}
-
-#[test]
-fn json_output_exception() {
-    let obj = MontyObject::Exception {
-        exc_type: ExcType::ValueError,
-        arg: Some("test".to_string()),
-    };
-    assert_eq!(
-        serde_json::to_string(&obj).unwrap(),
-        r#"{"Exception":{"exc_type":"ValueError","arg":"test"}}"#
-    );
-}
-
-#[test]
-fn json_output_repr() {
-    let obj = MontyObject::Repr("<function foo>".to_string());
-    assert_eq!(serde_json::to_string(&obj).unwrap(), r#"{"Repr":"<function foo>"}"#);
-}
-
-#[test]
-fn json_output_cycle_list() {
-    // Test JSON serialization of cyclic list
-    let ex = MontyRun::new("a = []; a.append(a); a".to_owned(), "test.py", vec![]).unwrap();
-    let result = ex.run_no_limits(vec![]).unwrap();
-    // The cyclic reference becomes MontyObject::Cycle
-    assert_eq!(
-        serde_json::to_string(&result).unwrap(),
-        r#"{"List":[{"Cycle":[1,"[...]"]}]}"#
-    );
-}
-
-#[test]
-fn json_output_cycle_dict() {
-    // Test JSON serialization of cyclic dict
-    let ex = MontyRun::new("d = {}; d['self'] = d; d".to_owned(), "test.py", vec![]).unwrap();
-    let result = ex.run_no_limits(vec![]).unwrap();
-    assert_eq!(
-        serde_json::to_string(&result).unwrap(),
-        r#"{"Dict":[[{"String":"self"},{"Cycle":[1,"{...}"]}]]}"#
-    );
-}
-
-// === JSON Deserialization Tests ===
-
-#[test]
-fn json_deserialize_primitives() {
-    // Deserialize tagged format
-    let int: MontyObject = serde_json::from_str(r#"{"Int":42}"#).unwrap();
-    let float: MontyObject = serde_json::from_str(r#"{"Float":2.5}"#).unwrap();
-    let string: MontyObject = serde_json::from_str(r#"{"String":"hello"}"#).unwrap();
-    let bool_val: MontyObject = serde_json::from_str(r#"{"Bool":true}"#).unwrap();
-    let null: MontyObject = serde_json::from_str(r#""None""#).unwrap();
-
-    assert_eq!(int, MontyObject::Int(42));
-    assert_eq!(float, MontyObject::Float(2.5));
-    assert_eq!(string, MontyObject::String("hello".to_string()));
-    assert_eq!(bool_val, MontyObject::Bool(true));
-    assert_eq!(null, MontyObject::None);
-}
-
-#[test]
-fn json_deserialize_list() {
-    let list: MontyObject = serde_json::from_str(r#"{"List":[{"Int":1},{"String":"two"},{"Float":3.0}]}"#).unwrap();
-    assert_eq!(
-        list,
-        MontyObject::List(vec![
-            MontyObject::Int(1),
-            MontyObject::String("two".to_string()),
-            MontyObject::Float(3.0)
-        ])
-    );
-}
-
-#[test]
-fn json_deserialize_dict() {
-    let dict: MontyObject =
-        serde_json::from_str(r#"{"Dict":[[{"String":"a"},{"Int":1}],[{"String":"b"},{"Int":2}]]}"#).unwrap();
-    if let MontyObject::Dict(pairs) = dict {
-        let pairs_vec: Vec<_> = pairs.into_iter().collect();
-        assert_eq!(pairs_vec.len(), 2);
-        assert_eq!(
-            pairs_vec[0],
-            (MontyObject::String("a".to_string()), MontyObject::Int(1))
-        );
-        assert_eq!(
-            pairs_vec[1],
-            (MontyObject::String("b".to_string()), MontyObject::Int(2))
-        );
-    } else {
-        panic!("expected Dict");
-    }
-}
-
-// === Round-trip Tests ===
-
-#[test]
-fn json_roundtrip() {
-    // Values round-trip through JSON correctly
-    let ex = MontyRun::new(
-        "{'items': [1, 'two', None], 'flag': True}".to_owned(),
-        "test.py",
-        vec![],
-    )
-    .unwrap();
-    let result = ex.run_no_limits(vec![]).unwrap();
-    let json = serde_json::to_string(&result).unwrap();
-    let parsed: MontyObject = serde_json::from_str(&json).unwrap();
-    assert_eq!(result, parsed);
-}
-
-#[test]
-fn json_roundtrip_empty() {
-    // Empty structures round-trip correctly
-    let list: MontyObject = serde_json::from_str(r#"{"List":[]}"#).unwrap();
-    let dict: MontyObject = serde_json::from_str(r#"{"Dict":[]}"#).unwrap();
-    assert_eq!(serde_json::to_string(&list).unwrap(), r#"{"List":[]}"#);
-    assert_eq!(serde_json::to_string(&dict).unwrap(), r#"{"Dict":[]}"#);
-}
-
-// === Cycle Equality Tests ===
-
-#[test]
-fn cycle_equality_same_id() {
-    // Multiple references to the same cyclic object should produce equal Cycle values
-    let ex = MontyRun::new("a = []; a.append(a); [a, a]".to_owned(), "test.py", vec![]).unwrap();
-    let result = ex.run_no_limits(vec![]).unwrap();
-
-    if let MontyObject::List(outer) = &result {
-        assert_eq!(outer.len(), 2, "outer list should have 2 elements");
-
-        if let (MontyObject::List(inner1), MontyObject::List(inner2)) = (&outer[0], &outer[1]) {
-            assert_eq!(inner1.len(), 1);
-            assert_eq!(inner2.len(), 1);
-            assert_eq!(inner1[0], inner2[0], "cycles referencing same object should be equal");
-            assert!(matches!(&inner1[0], MontyObject::Cycle(..)));
-        } else {
-            panic!("expected inner lists");
-        }
-    } else {
-        panic!("expected outer list");
-    }
-}
-
-#[test]
-fn cycle_equality_different_ids() {
-    // Two separate cyclic objects should produce unequal Cycle values
-    let ex = MontyRun::new(
-        "a = []; a.append(a); b = []; b.append(b); [a, b]".to_owned(),
-        "test.py",
-        vec![],
-    )
-    .unwrap();
-    let result = ex.run_no_limits(vec![]).unwrap();
-
-    if let MontyObject::List(outer) = &result {
-        assert_eq!(outer.len(), 2, "outer list should have 2 elements");
-
-        if let (MontyObject::List(inner1), MontyObject::List(inner2)) = (&outer[0], &outer[1]) {
-            assert_eq!(inner1.len(), 1);
-            assert_eq!(inner2.len(), 1);
-            assert_ne!(
-                inner1[0], inner2[0],
-                "cycles referencing different objects should not be equal"
-            );
-
-            if let (MontyObject::Cycle(id1, ph1), MontyObject::Cycle(id2, ph2)) = (&inner1[0], &inner2[0]) {
-                assert_ne!(id1, id2, "heap IDs should differ");
-                assert_eq!(ph1, ph2, "placeholders should match (both are lists)");
-                assert_eq!(*ph1, "[...]");
-            } else {
-                panic!("expected Cycle variants");
-            }
-        } else {
-            panic!("expected inner lists");
-        }
-    } else {
-        panic!("expected outer list");
-    }
-}