datahold 4.0.0.dev31__tar.gz → 4.0.0.dev32__tar.gz

{datahold-4.0.0.dev31 → datahold-4.0.0.dev32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 4.0.0.dev31
+Version: 4.0.0.dev32
 Summary: This project wraps common mutable datastructures for inheritance with modification.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT

{datahold-4.0.0.dev31 → datahold-4.0.0.dev32}/pyproject.toml

@@ -31,7 +31,7 @@ license-files = [
 name = "datahold"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "4.0.0.dev31"
+version = "4.0.0.dev32"
 
 [project.urls]
 Download = "https://pypi.org/project/datahold/#files"

{datahold-4.0.0.dev31 → datahold-4.0.0.dev32}/src/datahold/__init__.py

@@ -89,15 +89,17 @@ class SupportsAddAndDiscard[Item: abc.Hashable](Protocol):
 class Mapping_Frozen[Key, Value](Collection_Frozen[Key], Protocol):
     @setdoc.basic
     def __getitem__(self: Self, key: Never, /) -> Value: ...
+
+
 class SupportsDelitemAndSetitem[Key, Value](
     Protocol,
 ):
     @setdoc.basic
-    def __delitem__(self: Self, key: Key | str, /) -> object: ...
+    def __delitem__(self: Self, key: Key, /) -> object: ...
     @setdoc.basic
-    def __setitem__(
-        self: Self, key: Key | str, value: Value | None, /
-    ) -> object: ...
+    def __setitem__(self: Self, key: Key, value: Value, /) -> object: ...
+
+
 class Sequence_Frozen[Item](
     Collection_Frozen[Item],
     Protocol,
@@ -481,7 +483,7 @@ class Mapping[Key: abc.Hashable, Value](
 
 
 class MutableMapping[Key: abc.Hashable, Value](
-    Mapping[Key, Value],
+    Mapping[Key | str, Value | None],
     abc.MutableMapping[Key | str, Value | None],
     MutableObject[
         Mapping_Frozen[Key | str, Value | None],
@@ -509,8 +511,8 @@ class MutableMapping[Key: abc.Hashable, Value](
 
 
 class DictLike[Key: abc.Hashable, Value](
-    Mapping[Key | str, Value | None],
-    abc.Reversible[Key | str],
+    Mapping[Key, Value],
+    abc.Reversible[Key],
 ):
     """Provide abc for custom dict-like."""
 
@@ -518,7 +520,7 @@ class DictLike[Key: abc.Hashable, Value](
 
     @abstractmethod
     @setdoc.basic
-    def __frozen__(self: Self, /) -> FrozenDict[Key, Value]: ...
+    def __frozen__(self: Self, /) -> frozendict[Key, Value]: ...
 
     @abstractmethod
     @setdoc.basic
@@ -528,38 +530,54 @@ class DictLike[Key: abc.Hashable, Value](
         /,
         **kwargs: Value,
     ): ...
+
     @setdoc.basic
     def __or__[Key_: abc.Hashable, Value_](
         self: Self,
-        other: Dict_Init[Key_, Value_],
+        other: DictLike[Key_, Value_],
         /,
     ) -> DictLike[Key | Key_, Value | Value_]:
-        other_: FrozenDict[Key, Value]
-        try:
-            other_ = frozendict(other)  # type: ignore[arg-type]
-        except TypeError:
+        if isinstance(other, DictLike):
+            return type(self)(  # type: ignore[return-value]
+                self.__frozen__() | other  # type: ignore[arg-type]
+            )
+        else:
             return NotImplemented
-        return type(self)(  # type: ignore[return-value]
-            self.__frozen__() | other_
-        )
 
     @setdoc.basic
-    def __reversed__(self: Self, /) -> abc.Iterator[Key | str]:
+    def __reversed__(self: Self, /) -> abc.Iterator[Key]:
         yield from reversed(self.__frozen__())
 
+    @overload
     @classmethod
     @setdoc.basic
     def fromkeys(
         cls: type[Self],
-        iterable: abc.Iterable[Key | str],
-        value: Value | None = None,
+        iterable: abc.Iterable[Key],
         /,
-    ) -> Self:
+    ) -> DictLike[Key, None]: ...
+    @overload
+    @classmethod
+    @setdoc.basic
+    def fromkeys(
+        cls: type[Self],
+        iterable: abc.Iterable[Key],
+        value: Value,
+        /,
+    ) -> Self: ...
+    @classmethod
+    @setdoc.basic
+    def fromkeys(
+        cls: type[Self],
+        iterable: abc.Iterable[Key],
+        value: Any = None,
+        /,
+    ) -> Any:
         return cls(dict.fromkeys(iterable, value))
 
 
 class FrozenDictLike[Key: abc.Hashable, Value](
-    FrozenObjectLike[FrozenDict[Key, Value]],
+    FrozenObjectLike[frozendict[Key, Value]],
     DictLike[Key, Value],
 ):
     """Provide abc for custom frozen dict-like."""
@@ -568,7 +586,7 @@ class FrozenDictLike[Key: abc.Hashable, Value](
 
 
 class MutableDictLike[Key: abc.Hashable, Value](
-    DictLike[Key, Value],
+    DictLike[Key | str, Value | None],
     MutableObjectLike[FrozenDict[Key, Value], Dict[Key, Value]],
     MutableMapping[Key, Value],
 ):
@@ -590,7 +608,7 @@ class MutableDictLike[Key: abc.Hashable, Value](
         other: Dict_Init[Key, Value] = (),
         /,
         **kwargs: Value | None,
-    ):
+    ) -> None:
         self.update(
             other,  # type: ignore[arg-type]
             **kwargs,
@@ -619,7 +637,7 @@ class MutableDictLike[Key: abc.Hashable, Value](
 
 
 class FrozenDictSlot[Key: abc.Hashable, Value](
-    FrozenObjectSlot[FrozenDict[Key, Value]],
+    FrozenObjectSlot[frozendict[Key, Value]],
     FrozenDictLike[Key, Value],
 ):
     """Provide slotted frozen dict-like."""

{datahold-4.0.0.dev31 → datahold-4.0.0.dev32}/src/datahold.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 4.0.0.dev31
+Version: 4.0.0.dev32
 Summary: This project wraps common mutable datastructures for inheritance with modification.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT

{datahold-4.0.0.dev31 → datahold-4.0.0.dev32}/tests/test_FrozenDictSlot.py

@@ -17,7 +17,6 @@ __all__: list[str] = [
     "TestOperatorReversed",
     "TestOperatorSubscription",
     "TestOperatorTruth",
-    "TestOperatorUnion",
 ]
 import unittest
 from collections import abc
@@ -430,46 +429,6 @@ class TestOperatorInequality(unittest.TestCase):
         self.assertFalse(value != {"a": 1})
 
 
-class TestOperatorUnion(unittest.TestCase):
-    def test_disjoint_mappings(self: Self, /) -> None:
-        left: FrozenDictSlot[Any, Any]
-        result: Any
-        left = FrozenDictSlot({"a": 1})
-        result = left | {"b": 2}
-        self.assertEqual(result, {"a": 1, "b": 2})
-
-    def test_right_operand_overrides(self: Self, /) -> None:
-        left: FrozenDictSlot[Any, Any]
-        result: Any
-        left = FrozenDictSlot({"a": 1, "b": 2})
-        result = left | {"b": 20}
-        self.assertEqual(result, {"a": 1, "b": 20})
-
-    def test_union_with_empty_dictionary(self: Self, /) -> None:
-        left: FrozenDictSlot[Any, Any]
-        result: Any
-        left = FrozenDictSlot({"a": 1})
-        result = left | {}
-        self.assertEqual(result, {"a": 1})
-
-    def test_union_does_not_change_left_operand(self: Self, /) -> None:
-        answer: FrozenDictSlot[str, int]
-        left: FrozenDictSlot[str, int]
-        solution: FrozenDictSlot[str, int]
-        left = FrozenDictSlot({"a": 1})
-        answer = left | {"b": 2}  # type: ignore[operator]
-        # this is the only mypy suppression
-        # that seemingly stems not from a faulty typeshed
-        # but from a fault in mypy itself
-        # FrozenDictSlot[str, int].__or__
-        # annotates SupportsKeyAndGetitem[str, int | None]
-        # which is covariant in the second parameter
-        # and therefore should work
-        solution = FrozenDictSlot({"a": 1, "b": 2})
-        self.assertEqual(answer, solution)
-        self.assertEqual(left, {"a": 1})
-
-
 class TestOperatorLength(unittest.TestCase):
     def test_empty_mapping(self: Self, /) -> None:
         self.assertEqual(len(FrozenDictSlot({})), 0)

{datahold-4.0.0.dev31 → datahold-4.0.0.dev32}/tests/test_MutableDictSlot.py

@@ -1,3 +1,30 @@
+__all__: list[str] = [
+    "TestMethodClear",
+    "TestMethodCopy",
+    "TestMethodFromKeys",
+    "TestMethodGet",
+    "TestMethodItems",
+    "TestMethodKeys",
+    "TestMethodPop",
+    "TestMethodPopItem",
+    "TestMethodSetDefault",
+    "TestMethodUpdate",
+    "TestMethodValues",
+    "TestOperatorContains",
+    "TestOperatorDelItem",
+    "TestOperatorEqual",
+    "TestOperatorGetItem",
+    "TestOperatorInPlaceUnion",
+    "TestOperatorIteration",
+    "TestOperatorLength",
+    "TestOperatorNotEqual",
+    "TestOperatorReversed",
+    "TestOperatorReverseUnion",
+    "TestOperatorSetItem",
+    "TestOperatorTruthiness",
+]
+
+
 import unittest
 from collections import abc
 from typing import Any, Self
@@ -5,7 +32,7 @@ from typing import Any, Self
 from datahold import MutableDictSlot
 
 
-class TestClear(unittest.TestCase):
+class TestMethodClear(unittest.TestCase):
     def test_clear_removes_all_entries(self: Self, /) -> None:
         value: MutableDictSlot[Any, Any]
         value = MutableDictSlot({"a": 1, "b": 2})
@@ -40,7 +67,7 @@ class TestClear(unittest.TestCase):
         self.assertEqual(list(items_view), [])
 
 
-class TestCopy(unittest.TestCase):
+class TestMethodCopy(unittest.TestCase):
     def test_copy_has_equal_contents(self: Self, /) -> None:
         copied: MutableDictSlot[Any, Any]
         original: MutableDictSlot[Any, Any]
@@ -79,9 +106,9 @@ class TestCopy(unittest.TestCase):
         self.assertEqual(copied, {"a": 2, "b": 3})
 
 
-class TestFromKeys(unittest.TestCase):
+class TestMethodFromKeys(unittest.TestCase):
     def test_fromkeys_uses_none_by_default(self: Self, /) -> None:
-        result: MutableDictSlot[Any, Any]
+        result: Any
         result = MutableDictSlot.fromkeys(["a", "b", "c"])
         self.assertEqual(result, {"a": None, "b": None, "c": None})
         self.assertEqual(list(result), ["a", "b", "c"])
@@ -109,7 +136,7 @@ class TestFromKeys(unittest.TestCase):
         self.assertEqual(result["b"], [1])
 
 
-class TestGet(unittest.TestCase):
+class TestMethodGet(unittest.TestCase):
     def test_get_returns_existing_value(self: Self, /) -> None:
         value: MutableDictSlot[Any, Any]
         value = MutableDictSlot({"a": 1})
@@ -140,7 +167,7 @@ class TestGet(unittest.TestCase):
         self.assertEqual(value, {"a": 1})
 
 
-class TestItems(unittest.TestCase):
+class TestMethodItems(unittest.TestCase):
     def test_items_contains_key_value_pairs(self: Self, /) -> None:
         result: abc.Collection[Any]
         value: MutableDictSlot[Any, Any]
@@ -180,7 +207,7 @@ class TestItems(unittest.TestCase):
         self.assertNotIn(("missing", 1), result)
 
 
-class TestKeys(unittest.TestCase):
+class TestMethodKeys(unittest.TestCase):
     def test_keys_contains_all_keys(self: Self, /) -> None:
         result: abc.Collection[Any]
         value: MutableDictSlot[Any, Any]
@@ -220,7 +247,7 @@ class TestKeys(unittest.TestCase):
         self.assertNotIn(1, result)
 
 
-class TestPop(unittest.TestCase):
+class TestMethodPop(unittest.TestCase):
     def test_pop_returns_and_removes_existing_value(self: Self, /) -> None:
         result: Any
         value: MutableDictSlot[Any, Any]
@@ -256,7 +283,7 @@ class TestPop(unittest.TestCase):
         self.assertEqual(value, {})
 
 
-class TestPopItem(unittest.TestCase):
+class TestMethodPopItem(unittest.TestCase):
     def test_popitem_removes_last_inserted_pair(self: Self, /) -> None:
         result: tuple[Any, Any]
         value: MutableDictSlot[Any, Any]
@@ -295,7 +322,7 @@ class TestPopItem(unittest.TestCase):
         self.assertEqual(value, {})
 
 
-class TestSetDefault(unittest.TestCase):
+class TestMethodSetDefault(unittest.TestCase):
     def test_setdefault_returns_existing_value(self: Self, /) -> None:
         result: Any
         value: MutableDictSlot[Any, Any]
@@ -335,7 +362,7 @@ class TestSetDefault(unittest.TestCase):
         self.assertEqual(value["a"], [1])
 
 
-class TestUpdate(unittest.TestCase):
+class TestMethodUpdate(unittest.TestCase):
     def test_update_from_mapping(self: Self, /) -> None:
         value: MutableDictSlot[Any, Any]
         value = MutableDictSlot({"a": 1})
@@ -363,7 +390,7 @@ class TestUpdate(unittest.TestCase):
         self.assertEqual(value, {"a": 10, "b": 20, "c": 30})
 
 
-class TestValues(unittest.TestCase):
+class TestMethodValues(unittest.TestCase):
     def test_values_contains_all_values(self: Self, /) -> None:
         result: Any
         value: MutableDictSlot[Any, Any]
@@ -400,5 +427,287 @@ class TestValues(unittest.TestCase):
         self.assertEqual(result.count(1), 2)
 
 
+class TestOperatorGetItem(unittest.TestCase):
+    def test_existing_key(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"name": "Alice"})
+        self.assertEqual(slot["name"], "Alice")
+
+    def test_missing_key_raises_key_error(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"name": "Alice"})
+        with self.assertRaises(KeyError):
+            _ = slot["missing"]
+
+    def test_none_value(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"value": None})
+        self.assertIsNone(slot["value"])
+
+    def test_unhashable_key_raises_type_error(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot()
+        with self.assertRaises(Exception):
+            _ = slot[["unhashable"]]
+
+
+class TestOperatorSetItem(unittest.TestCase):
+    def test_adds_new_key(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot()
+        slot["name"] = "Alice"
+        self.assertEqual(slot, {"name": "Alice"})
+
+    def test_replaces_existing_value(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"count": 1})
+        slot["count"] = 2
+        self.assertEqual(slot["count"], 2)
+
+    def test_accepts_none_value(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot()
+        slot["value"] = None
+        self.assertIn("value", slot)
+        self.assertIsNone(slot["value"])
+
+    def test_unhashable_key_raises_type_error(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot()
+        with self.assertRaises(TypeError):
+            slot[["unhashable"]] = "value"
+
+
+class TestOperatorDelItem(unittest.TestCase):
+    def test_deletes_existing_key(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1, "b": 2})
+        del slot["a"]
+        self.assertEqual(slot, {"b": 2})
+
+    def test_missing_key_raises_key_error(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1})
+        with self.assertRaises(KeyError):
+            del slot["missing"]
+
+    def test_delete_only_item_makes_empty(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1})
+        del slot["a"]
+        self.assertEqual(slot, {})
+
+    def test_unhashable_key_raises_type_error(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1})
+        with self.assertRaises(TypeError):
+            del slot[["unhashable"]]
+
+
+class TestOperatorContains(unittest.TestCase):
+    def test_existing_key_is_contained(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1})
+        self.assertIn("a", slot)
+
+    def test_missing_key_is_not_contained(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1})
+        self.assertNotIn("b", slot)
+
+    def test_values_are_not_checked(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": "value"})
+        self.assertNotIn("value", slot)
+
+    def test_unhashable_key_raises_type_error(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1})
+        self.assertFalse(["unhashable"] in slot)
+
+
+class TestOperatorEqual(unittest.TestCase):
+    def test_equal_contents(self: Self, /) -> None:
+        x: MutableDictSlot[str, int]
+        y: MutableDictSlot[str, int]
+        x = MutableDictSlot({"a": 1, "b": 2})
+        y = MutableDictSlot({"a": 1, "b": 2})
+        self.assertTrue(x == x)
+        self.assertTrue(x == y)
+
+    def test_order_does_not_affect_equality(self: Self, /) -> None:
+        x: MutableDictSlot[str, int]
+        y: MutableDictSlot[str, int]
+        x = MutableDictSlot({"a": 1, "b": 2})
+        y = MutableDictSlot({"b": 2, "a": 1})
+        self.assertTrue(x == y)
+
+    def test_equal_to_plain_dict(self: Self, /) -> None:
+        slot: MutableDictSlot[str, int]
+        slot = MutableDictSlot[str, int]({"a": 1})
+        self.assertTrue(slot == {"a": 1})
+
+    def test_different_values_are_not_equal(self: Self, /) -> None:
+        slot: MutableDictSlot[str, int]
+        slot = MutableDictSlot[str, int]({"a": 1})
+        self.assertFalse(slot == {"a": 2})
+
+
+class TestOperatorNotEqual(unittest.TestCase):
+    def test_different_values(self: Self, /) -> None:
+        slot: MutableDictSlot[str, int]
+        slot = MutableDictSlot[str, int]({"a": 1})
+        self.assertTrue(slot != {"a": 2})
+
+    def test_different_keys(self: Self, /) -> None:
+        slot: MutableDictSlot[str, int]
+        slot = MutableDictSlot[str, int]({"a": 1})
+        self.assertTrue(slot != {"b": 1})
+
+    def test_different_lengths(self: Self, /) -> None:
+        slot: MutableDictSlot[str, int]
+        slot = MutableDictSlot[str, int]({"a": 1})
+        self.assertTrue(slot != {"a": 1, "b": 2})
+
+    def test_identical_contents_are_not_unequal(self: Self, /) -> None:
+        slot: MutableDictSlot[str, int]
+        slot = MutableDictSlot[str, int]({"a": 1})
+        self.assertFalse(slot != {"a": 1})
+
+
+class TestOperatorInPlaceUnion(unittest.TestCase):
+    def test_adds_distinct_keys(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1})
+        slot |= {"b": 2}
+        self.assertEqual(slot, {"a": 1, "b": 2})
+
+    def test_overrides_duplicate_key(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1})
+        slot |= {"a": 2}
+        self.assertEqual(slot, {"a": 2})
+
+    def test_preserves_object_identity(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1})
+        original_id = id(slot)
+        slot |= {"b": 2}
+        self.assertEqual(id(slot), original_id)
+
+    def test_accepts_iterable_of_pairs(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1})
+        slot |= [("b", 2), ("c", 3)]
+        self.assertEqual(slot, {"a": 1, "b": 2, "c": 3})
+
+
+class TestOperatorIteration(unittest.TestCase):
+    def test_iterates_over_keys(self: Self, /) -> None:
+        slot: MutableDictSlot[str, int]
+        slot = MutableDictSlot({"a": 1, "b": 2})
+        self.assertEqual(list(slot), ["a", "b"])
+
+    def test_empty_slot_has_no_iterations(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot()
+        self.assertEqual(list(slot), [])
+
+    def test_iteration_preserves_insertion_order(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot()
+        slot["third"] = 3
+        slot["first"] = 1
+        slot["second"] = 2
+        self.assertEqual(list(slot), ["third", "first", "second"])
+
+    def test_size_change_during_iteration_raises_runtime_error(
+        self: Self, /
+    ) -> None:
+        init: list[tuple[str, int]]
+        x: dict[str, int]
+        x_iter: abc.Iterator[str]
+        x_next: str
+        y: MutableDictSlot[str, int]
+        y_iter: abc.Iterator[str]
+        y_next: str
+        init = [("a", 1), ("b", 2)]
+        x = dict(init)
+        y = MutableDictSlot(init)
+        x_iter = iter(x)
+        y_iter = iter(y)
+        x_next = next(x_iter)
+        y_next = next(y_iter)
+        self.assertEqual(x_next, y_next)
+        x["c"] = 3
+        y["c"] = 3
+        self.assertListEqual(list(x), list(y))
+        self.assertListEqual(list("abc"), list(y))
+
+
+class TestOperatorReversed(unittest.TestCase):
+    def test_reverses_key_order(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1, "b": 2, "c": 3})
+        self.assertEqual(list(reversed(slot)), ["c", "b", "a"])
+
+    def test_empty_slot_reverses_to_empty(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot()
+        self.assertEqual(list(reversed(slot)), [])
+
+    def test_single_key(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1})
+        self.assertEqual(list(reversed(slot)), ["a"])
+
+    def test_replacing_value_does_not_change_order(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1, "b": 2})
+        slot["a"] = 3
+        self.assertEqual(list(reversed(slot)), ["b", "a"])
+
+
+class TestOperatorLength(unittest.TestCase):
+    def test_empty_length(self: Self, /) -> None:
+        self.assertEqual(len(MutableDictSlot()), 0)
+
+    def test_nonempty_length(self: Self, /) -> None:
+        x: MutableDictSlot[str, int]
+        x = MutableDictSlot({"a": 1, "b": 2})
+        self.assertEqual(len(x), 2)
+
+    def test_replacing_value_does_not_change_length(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1})
+        slot["a"] = 2
+        self.assertEqual(len(slot), 1)
+
+    def test_adding_and_deleting_changes_length(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot()
+        slot["a"] = 1
+        slot["b"] = 2
+        del slot["a"]
+        self.assertEqual(len(slot), 1)
+
+
+class TestOperatorTruthiness(unittest.TestCase):
+    def test_empty_slot_is_false(self: Self, /) -> None:
+        self.assertFalse(MutableDictSlot())
+
+    def test_nonempty_slot_is_true(self: Self, /) -> None:
+        self.assertTrue(MutableDictSlot({"a": 1}))
+
+    def test_false_value_still_makes_slot_true(self: Self, /) -> None:
+        self.assertTrue(MutableDictSlot({"a": False}))
+
+    def test_deleting_last_key_makes_slot_false(self: Self, /) -> None:
+        slot: MutableDictSlot[Any, Any]
+        slot = MutableDictSlot({"a": 1})
+        del slot["a"]
+        self.assertFalse(slot)
+
+
 if __name__ == "__main__":
     unittest.main()