superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,420 @@
+//! 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

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