Add MappingKey/Tagged interaction tests and complex round-trip fixtures

- Add hashing/equality coverage for MappingKey wrapping Tagged values and verify
  Tagged-scalar key round-trips.
- Introduce fixtures for tagged outer mappings with tagged keys and a mixed YAML
  sample covering sequences/mappings/tagged keys/values, asserting parse and
  format_yaml round-trip.

Author: t-kalinowski

tests_py/test_mapping_keys.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import textwrap
+
 import yaml12
 
 
@@ -82,6 +84,31 @@ def test_mapping_key_hashes_by_structure():
     assert hash(k1) == hash(k2)
 
 
+def test_mapping_key_with_tagged_value_hashes_and_compares():
+    k1 = yaml12.MappingKey(yaml12.Tagged({"a": 1}, "!tag"))
+    k2 = yaml12.MappingKey(yaml12.Tagged({"a": 1}, "!tag"))
+
+    assert k1 == k2
+    assert hash(k1) == hash(k2)
+
+    mapping = {k1: "value"}
+    assert mapping[k2] == "value"
+
+
+def test_mapping_key_tagged_round_trip_format_and_parse():
+    key = yaml12.MappingKey(yaml12.Tagged("foo", "!k"))
+    original = {key: "v"}
+
+    encoded = yaml12.format_yaml(original)
+    reparsed = yaml12.parse_yaml(encoded)
+    reparsed_key = next(iter(reparsed))
+
+    assert isinstance(reparsed_key, yaml12.Tagged)
+    assert reparsed_key.tag == "!k"
+    assert reparsed_key.value == "foo"
+    assert reparsed == {yaml12.Tagged("foo", "!k"): "v"}
+
+
 def test_collection_values_stay_plain():
     parsed = yaml12.parse_yaml(
         "top:\n"
@@ -93,3 +120,61 @@ def test_collection_values_stay_plain():
     assert items[0] == [1, 2]
     assert isinstance(items[1], dict)
     assert not any(isinstance(k, yaml12.MappingKey) for k in items[1])
+
+
+def test_tagged_outer_mapping_with_tagged_keys_round_trip():
+    yaml_text = "!outer\n!k1 foo: 1\n!k2 bar: 2\n"
+
+    parsed = yaml12.parse_yaml(yaml_text)
+    assert isinstance(parsed, yaml12.Tagged)
+    assert parsed.tag == "!outer"
+    assert isinstance(parsed.value, dict)
+    keys = list(parsed.value.keys())
+    assert all(isinstance(k, yaml12.Tagged) for k in keys)
+    assert {k.tag for k in keys} == {"!k1", "!k2"}
+    assert parsed.value[keys[0]] in (1, 2)
+
+    encoded = yaml12.format_yaml(parsed)
+    reparsed = yaml12.parse_yaml(encoded)
+    assert reparsed == parsed
+
+
+def test_complex_tagged_and_untagged_mapping_keys_round_trip():
+    yaml_text = textwrap.dedent(
+        """\
+        ? [a, b]
+        : plain-seq
+        ? {foo: bar}
+        : !val {x: 1}
+        ? !tagged-key scalar
+        : [3, 4]
+        ? tagged_value_key
+        : !tagged-seq [5, 6]
+        """
+    )
+
+    parsed = yaml12.parse_yaml(yaml_text)
+    assert isinstance(parsed, dict)
+    assert len(parsed) == 4
+
+    keys = list(parsed.keys())
+    assert any(isinstance(k, yaml12.MappingKey) for k in keys)
+
+    seq_key = yaml12.MappingKey(["a", "b"])
+    map_key = yaml12.MappingKey({"foo": "bar"})
+    tagged_scalar_key = yaml12.Tagged("scalar", "!tagged-key")
+    plain_scalar_key = "tagged_value_key"
+
+    assert parsed[seq_key] == "plain-seq"
+    assert isinstance(parsed[map_key], yaml12.Tagged)
+    assert parsed[map_key].tag == "!val"
+    assert parsed[map_key].value == {"x": 1}
+    assert parsed[tagged_scalar_key] == [3, 4]
+    tagged_value = parsed[plain_scalar_key]
+    assert isinstance(tagged_value, yaml12.Tagged)
+    assert tagged_value.tag == "!tagged-seq"
+    assert tagged_value.value == [5, 6]
+
+    encoded = yaml12.format_yaml(parsed)
+    reparsed = yaml12.parse_yaml(encoded)
+    assert reparsed == parsed