datahold 4.0.0.dev26__tar.gz → 4.0.0.dev27__tar.gz

{datahold-4.0.0.dev26 → datahold-4.0.0.dev27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 4.0.0.dev26
+Version: 4.0.0.dev27
 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.dev26 → datahold-4.0.0.dev27}/pyproject.toml

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

{datahold-4.0.0.dev26 → datahold-4.0.0.dev27}/src/datahold/__init__.py

@@ -260,12 +260,12 @@ class SetLike[Item: abc.Hashable](Set[Item]):
         return type(self)(self.__frozen__().intersection(*others))
 
     @setdoc.basic
-    def issubset(self: Self, other: abc.Iterable[abc.Hashable], /) -> Self:
-        return type(self)(self.__frozen__().issubset(other))  # type: ignore
+    def issubset(self: Self, other: abc.Iterable[abc.Hashable], /) -> bool:
+        return self.__frozen__().issubset(other)
 
     @setdoc.basic
-    def issuperset(self: Self, other: abc.Iterable[abc.Hashable], /) -> Self:
-        return type(self)(self.__frozen__().issuperset(other))  # type: ignore
+    def issuperset(self: Self, other: abc.Iterable[abc.Hashable], /) -> bool:
+        return self.__frozen__().issuperset(other)
 
     @setdoc.basic
     def symmetric_difference(self: Self, other: abc.Iterable[Item], /) -> Self:
@@ -273,7 +273,7 @@ class SetLike[Item: abc.Hashable](Set[Item]):
 
     @setdoc.basic
     def union(self: Self, /, *others: abc.Iterable[Item]) -> Self:
-        return type(self)(self.__frozen__().union(others))  # type: ignore
+        return type(self)(self.__frozen__().union(*others))
 
 
 class FrozenSetLike[Item: abc.Hashable](SetLike[Item], abc.Hashable):
@@ -305,6 +305,11 @@ class MutableSetLike[Item: abc.Hashable](SetLike[Item], MutableSet[Item]):
     @abstractmethod
     @setdoc.basic
     def __mutate__(self: Self) -> ContextManager[__Mutable__[Item]]: ...
+
+    @setdoc.basic
+    def copy(self: Self, /) -> Self:
+        return type(self)(self)
+
     @setdoc.basic
     def difference_update(
         self: Self, /, *others: abc.Iterable[abc.Hashable]
@@ -525,6 +530,14 @@ class MutableDictLike[Key: abc.Hashable, Value](
     def copy(self: Self, /) -> Self:
         return type(self)(self)
 
+    @setdoc.basic
+    def popitem(self: Self, /) -> tuple[Key | str, Optional[Value]]:
+        # for most dict d
+        # dict.popitem(d) and collections.abc.MutableMapping.popitem(d)
+        # behave differently
+        with self.__mutate__() as mutable:
+            return mutable.popitem()
+
 
 ### DICT-SLOT ###
 

{datahold-4.0.0.dev26 → datahold-4.0.0.dev27}/src/datahold.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahold
-Version: 4.0.0.dev26
+Version: 4.0.0.dev27
 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.dev26 → datahold-4.0.0.dev27}/src/datahold.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ src/datahold.egg-info/top_level.txt
 tests/test_FrozenListSlot.py
 tests/test_MutableDictSlot.py
 tests/test_MutableListSlot.py
+tests/test_MutableSetSlot.py
 tests/test_abstractmethods.py
 tests/test_all.py
 tests/test_attributes.py

datahold-4.0.0.dev27/tests/test_MutableDictSlot.py

@@ -0,0 +1,403 @@
+import unittest
+from collections import abc
+from typing import Any, Self
+
+from datahold import MutableDictSlot
+
+
+class TestClear(unittest.TestCase):
+    def test_clear_removes_all_entries(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        value.clear()
+        self.assertEqual(value, {})
+        self.assertEqual(len(value), 0)
+
+    def test_clear_empty_mapping(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        value.clear()
+        self.assertEqual(value, {})
+        self.assertFalse(value)
+
+    def test_clear_returns_none(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        result = value.clear()  # type: ignore[func-returns-value]
+        self.assertIsNone(result)
+        self.assertEqual(value, {})
+
+    def test_clear_updates_existing_views(self: Self) -> None:
+        items_view: abc.Collection[Any]
+        keys_view: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        keys_view = value.keys()
+        items_view = value.items()
+        value.clear()
+        self.assertEqual(list(keys_view), [])
+        self.assertEqual(list(items_view), [])
+
+
+class TestCopy(unittest.TestCase):
+    def test_copy_has_equal_contents(self: Self) -> None:
+        copied: MutableDictSlot[Any, Any]
+        original: MutableDictSlot[Any, Any]
+        original = MutableDictSlot({"a": 1, "b": 2})
+        copied = original.copy()
+        self.assertEqual(copied, original)
+        self.assertIsNot(copied, original)
+
+    def test_copy_of_empty_mapping(self: Self) -> None:
+        copied: MutableDictSlot[Any, Any]
+        original: MutableDictSlot[Any, Any]
+        original = MutableDictSlot()
+        copied = original.copy()
+        self.assertEqual(copied, {})
+        self.assertIsNot(copied, original)
+
+    def test_copy_is_shallow(self: Self) -> None:
+        copied: MutableDictSlot[Any, Any]
+        nested: list[int]
+        original: MutableDictSlot[Any, Any]
+        nested = [1, 2]
+        original = MutableDictSlot({"nested": nested})
+        copied = original.copy()
+        copied["nested"].append(3)  # type: ignore
+        self.assertIs(copied["nested"], original["nested"])
+        self.assertEqual(original["nested"], [1, 2, 3])
+
+    def test_copy_has_independent_top_level_entries(self: Self) -> None:
+        copied: MutableDictSlot[Any, Any]
+        original: MutableDictSlot[Any, Any]
+        original = MutableDictSlot({"a": 1})
+        copied = original.copy()
+        copied["a"] = 2
+        copied["b"] = 3
+        self.assertEqual(original, {"a": 1})
+        self.assertEqual(copied, {"a": 2, "b": 3})
+
+
+class TestFromKeys(unittest.TestCase):
+    def test_fromkeys_uses_none_by_default(self: Self) -> None:
+        result: MutableDictSlot[Any, Any]
+        result = MutableDictSlot.fromkeys(["a", "b", "c"])
+        self.assertEqual(result, {"a": None, "b": None, "c": None})
+        self.assertEqual(list(result), ["a", "b", "c"])
+
+    def test_fromkeys_uses_supplied_value(self: Self) -> None:
+        result: MutableDictSlot[Any, Any]
+        result = MutableDictSlot.fromkeys(["a", "b"], 10)
+        self.assertEqual(result, {"a": 10, "b": 10})
+        self.assertEqual(result["a"], 10)
+
+    def test_fromkeys_ignores_duplicate_keys(self: Self) -> None:
+        result: MutableDictSlot[Any, Any]
+        result = MutableDictSlot.fromkeys(["a", "b", "a", "c", "b"], 0)
+        self.assertEqual(result, {"a": 0, "b": 0, "c": 0})
+        self.assertEqual(list(result), ["a", "b", "c"])
+
+    def test_fromkeys_reuses_same_mutable_value(self: Self) -> None:
+        result: MutableDictSlot[Any, Any]
+        shared: list[Any]
+        shared = []
+        result = MutableDictSlot.fromkeys(["a", "b"], shared)
+        result["a"].append(1)  # type: ignore
+        self.assertIs(result["a"], shared)
+        self.assertIs(result["b"], shared)
+        self.assertEqual(result["b"], [1])
+
+
+class TestGet(unittest.TestCase):
+    def test_get_returns_existing_value(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        self.assertEqual(value.get("a"), 1)
+        self.assertEqual(value, {"a": 1})
+
+    def test_get_returns_none_for_missing_key(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        result = value.get("missing")
+        self.assertIsNone(result)
+        self.assertNotIn("missing", value)
+
+    def test_get_returns_custom_default(self: Self) -> None:
+        default: object
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        default = object()
+        result = value.get("missing", default)
+        self.assertIs(result, default)
+        self.assertEqual(value, {})
+
+    def test_get_rejects_unhashable_key(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        with self.assertRaises(TypeError):
+            value.get([])
+        self.assertEqual(value, {"a": 1})
+
+
+class TestItems(unittest.TestCase):
+    def test_items_contains_key_value_pairs(self: Self) -> None:
+        result: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.items()
+        self.assertEqual(set(result), {("a", 1), ("b", 2)})
+        self.assertEqual(len(result), 2)
+
+    def test_items_preserves_iteration_order(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        value["first"] = 1
+        value["second"] = 2
+        value["third"] = 3
+        self.assertEqual(
+            list(value.items()),
+            [("first", 1), ("second", 2), ("third", 3)],
+        )
+
+    def test_items_view_is_dynamic(self: Self) -> None:
+        result: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        result = value.items()
+        value["a"] = 2
+        value["b"] = 3
+        self.assertEqual(list(result), [("a", 2), ("b", 3)])
+
+    def test_items_supports_pair_membership(self: Self) -> None:
+        result: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.items()
+        self.assertIn(("a", 1), result)
+        self.assertIn(("b", 2), result)
+        self.assertNotIn(("a", 2), result)
+        self.assertNotIn(("missing", 1), result)
+
+
+class TestKeys(unittest.TestCase):
+    def test_keys_contains_all_keys(self: Self) -> None:
+        result: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.keys()
+        self.assertEqual(set(result), {"a", "b"})
+        self.assertEqual(len(result), 2)
+
+    def test_keys_preserves_iteration_order(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        value["first"] = 1
+        value["second"] = 2
+        value["third"] = 3
+        self.assertEqual(
+            list(value.keys()),
+            ["first", "second", "third"],
+        )
+
+    def test_keys_view_is_dynamic(self: Self) -> None:
+        result: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.keys()
+        del value["a"]
+        value["c"] = 3
+        self.assertEqual(list(result), ["b", "c"])
+
+    def test_keys_supports_membership(self: Self) -> None:
+        result: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.keys()
+        self.assertIn("a", result)
+        self.assertIn("b", result)
+        self.assertNotIn("missing", result)
+        self.assertNotIn(1, result)
+
+
+class TestPop(unittest.TestCase):
+    def test_pop_returns_and_removes_existing_value(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.pop("a")
+        self.assertEqual(result, 1)
+        self.assertEqual(value, {"b": 2})
+
+    def test_pop_missing_key_raises_key_error(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        with self.assertRaises(KeyError) as context:
+            value.pop("missing")
+        self.assertEqual(context.exception.args, ("missing",))
+        self.assertEqual(value, {"a": 1})
+
+    def test_pop_missing_key_returns_default(self: Self) -> None:
+        default: object
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        default = object()
+        result = value.pop("missing", default)
+        self.assertIs(result, default)
+        self.assertEqual(value, {"a": 1})
+
+    def test_pop_handles_none_as_explicit_default(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        result = value.pop("missing", None)
+        self.assertIsNone(result)
+        self.assertEqual(value, {})
+
+
+class TestPopItem(unittest.TestCase):
+    def test_popitem_removes_last_inserted_pair(self: Self) -> None:
+        result: tuple[Any, Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2, "c": 3})
+        result = value.popitem()
+        self.assertEqual(result, ("c", 3))
+        self.assertEqual(value, {"a": 1, "b": 2})
+
+    def test_popitem_uses_lifo_order_repeatedly(self: Self) -> None:
+        first: tuple[Any, Any]
+        second: tuple[Any, Any]
+        third: tuple[Any, Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2, "c": 3})
+        first = value.popitem()
+        second = value.popitem()
+        third = value.popitem()
+        self.assertEqual(first, ("c", 3))
+        self.assertEqual(second, ("b", 2))
+        self.assertEqual(third, ("a", 1))
+        self.assertEqual(len(value), 0)
+
+    def test_popitem_removes_only_entry(self: Self) -> None:
+        result: tuple[Any, Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        result = value.popitem()
+        self.assertEqual(result, ("a", 1))
+        self.assertEqual(value, {})
+
+    def test_popitem_empty_mapping_raises_key_error(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        with self.assertRaises(KeyError):
+            value.popitem()
+        self.assertEqual(value, {})
+
+
+class TestSetDefault(unittest.TestCase):
+    def test_setdefault_returns_existing_value(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        result = value.setdefault("a", 2)
+        self.assertEqual(result, 1)
+        self.assertEqual(value, {"a": 1})
+
+    def test_setdefault_inserts_supplied_default(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        result = value.setdefault("b", 2)
+        self.assertEqual(result, 2)
+        self.assertEqual(value, {"a": 1, "b": 2})
+
+    def test_setdefault_inserts_none_by_default(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        result = value.setdefault("a")
+        self.assertIsNone(result)
+        self.assertEqual(value, {"a": None})
+
+    def test_setdefault_preserves_mutable_default_identity(self: Self) -> None:
+        default: list[Any]
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        default = []
+        result = value.setdefault("a", default)
+        result.append(1)
+        self.assertIs(result, default)
+        self.assertIs(value["a"], default)
+        self.assertEqual(value["a"], [1])
+
+
+class TestUpdate(unittest.TestCase):
+    def test_update_from_mapping(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        value.update({"b": 2, "c": 3})
+        self.assertEqual(value, {"a": 1, "b": 2, "c": 3})
+
+    def test_update_from_iterable_of_pairs(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        value.update([("b", 2), ("c", 3)])
+        self.assertEqual(value, {"a": 1, "b": 2, "c": 3})
+
+    def test_update_from_keyword_arguments(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1})
+        value.update(b=2, c=3)
+        self.assertEqual(value, {"a": 1, "b": 2, "c": 3})
+
+    def test_update_overwrites_values_and_returns_none(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.update({"a": 10}, b=20, c=30)
+        self.assertIsNone(result)
+        self.assertEqual(value, {"a": 10, "b": 20, "c": 30})
+
+
+class TestValues(unittest.TestCase):
+    def test_values_contains_all_values(self: Self) -> None:
+        result: Any
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2, "c": 3})
+        result = value.values()
+        self.assertEqual(list(result), [1, 2, 3])
+        self.assertEqual(len(result), 3)
+
+    def test_values_preserves_iteration_order(self: Self) -> None:
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot()
+        value["first"] = 10
+        value["second"] = 20
+        value["third"] = 30
+
+        self.assertEqual(list(value.values()), [10, 20, 30])
+
+    def test_values_view_is_dynamic(self: Self) -> None:
+        result: abc.Collection[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 2})
+        result = value.values()
+        value["a"] = 10
+        del value["b"]
+        value["c"] = 3
+        self.assertEqual(list(result), [10, 3])
+
+    def test_values_preserves_duplicate_values(self: Self) -> None:
+        result: list[Any]
+        value: MutableDictSlot[Any, Any]
+        value = MutableDictSlot({"a": 1, "b": 1, "c": 2})
+        result = list(value.values())
+        self.assertEqual(result, [1, 1, 2])
+        self.assertEqual(result.count(1), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

datahold-4.0.0.dev27/tests/test_MutableSetSlot.py

@@ -0,0 +1,477 @@
+import unittest
+from typing import Any, Self
+
+from datahold import MutableSetSlot
+
+
+class TestAdd(unittest.TestCase):
+    def test_adds_new_element(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.add(3)
+        self.assertEqual(set(value), {1, 2, 3})
+
+    def test_adding_duplicate_does_not_change_set(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.add(2)
+        self.assertEqual(set(value), {1, 2})
+
+    def test_adds_hashable_tuple(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot()
+        value.add((1, 2))
+        self.assertEqual(set(value), {(1, 2)})
+
+    def test_adding_unhashable_element_raises_type_error(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1})
+        with self.assertRaises(TypeError):
+            value.add([2])
+        self.assertEqual(set(value), {1})
+
+
+class TestClear(unittest.TestCase):
+    def test_clears_populated_set(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.clear()
+        self.assertEqual(set(value), set())
+
+    def test_clearing_empty_set_keeps_it_empty(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot()
+        value.clear()
+        self.assertEqual(set(value), set())
+
+    def test_clear_returns_none(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertIsNone(value.clear())  # type: ignore[func-returns-value]
+
+    def test_set_can_be_reused_after_clear(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.clear()
+        value.add(3)
+        self.assertEqual(set(value), {3})
+
+
+class TestCopy(unittest.TestCase):
+    def test_copy_has_same_contents(self: Self) -> None:
+        copied: MutableSetSlot[Any]
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        copied = value.copy()
+        self.assertEqual(set(copied), {1, 2, 3})
+
+    def test_copy_is_a_different_object(self: Self) -> None:
+        copied: MutableSetSlot[Any]
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        copied = value.copy()
+        self.assertIsNot(copied, value)
+
+    def test_copy_is_independent_of_original(self: Self) -> None:
+        copied: MutableSetSlot[Any]
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        copied = value.copy()
+        copied.add(3)
+        self.assertEqual(set(value), {1, 2})
+        self.assertEqual(set(copied), {1, 2, 3})
+
+    def test_copy_of_empty_set_is_empty(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot()
+        copied = value.copy()
+        self.assertEqual(set(copied), set())
+
+
+class TestDifference(unittest.TestCase):
+    def test_difference_removes_shared_elements(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        result = value.difference({2, 3, 4})
+        self.assertEqual(set(result), {1})
+
+    def test_difference_accepts_multiple_iterables(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3, 4})
+        result = value.difference({1}, [2, 5])
+        self.assertEqual(set(result), {3, 4})
+
+    def test_difference_with_disjoint_set_is_unchanged(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        result = value.difference({3, 4})
+        self.assertEqual(set(result), {1, 2})
+
+    def test_difference_does_not_modify_original(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.difference({2})
+        self.assertEqual(set(value), {1, 2, 3})
+
+
+class TestDifferenceUpdate(unittest.TestCase):
+    def test_difference_update_removes_shared_elements(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.difference_update({2, 4})
+        self.assertEqual(set(value), {1, 3})
+
+    def test_difference_update_accepts_multiple_iterables(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3, 4})
+        value.difference_update({1}, [2, 5])
+        self.assertEqual(set(value), {3, 4})
+
+    def test_difference_update_with_disjoint_set_is_unchanged(
+        self: Self,
+    ) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.difference_update({3, 4})
+        self.assertEqual(set(value), {1, 2})
+
+    def test_difference_update_with_self_empties_set(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.difference_update(value)
+        self.assertEqual(set(value), set())
+
+
+class TestDiscard(unittest.TestCase):
+    def test_discards_existing_element(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.discard(2)
+        self.assertEqual(set(value), {1, 3})
+
+    def test_discarding_missing_element_does_not_raise(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.discard(3)
+        self.assertEqual(set(value), {1, 2})
+
+    def test_discard_returns_none(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertIsNone(value.discard(1))
+
+    def test_discarding_unhashable_element_raises_type_error(
+        self: Self,
+    ) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        with self.assertRaises(TypeError):
+            value.discard([1])  # type: ignore
+        self.assertEqual(set(value), {1, 2})
+
+
+class TestIntersection(unittest.TestCase):
+    def test_intersection_returns_shared_elements(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        result = value.intersection({2, 3, 4})
+        self.assertEqual(set(result), {2, 3})
+
+    def test_intersection_accepts_multiple_iterables(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3, 4})
+        result = value.intersection({2, 3, 4}, [3, 4, 5])
+        self.assertEqual(set(result), {3, 4})
+
+    def test_intersection_with_disjoint_set_is_empty(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        result = value.intersection({3, 4})
+        self.assertEqual(set(result), set())
+
+    def test_intersection_does_not_modify_original(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.intersection({2})
+        self.assertEqual(set(value), {1, 2, 3})
+
+
+class TestIntersectionUpdate(unittest.TestCase):
+    def test_intersection_update_keeps_shared_elements(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.intersection_update({2, 3, 4})
+        self.assertEqual(set(value), {2, 3})
+
+    def test_intersection_update_accepts_multiple_iterables(
+        self: Self,
+    ) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3, 4})
+        value.intersection_update({2, 3, 4}, [3, 4, 5])
+        self.assertEqual(set(value), {3, 4})
+
+    def test_intersection_update_with_disjoint_set_empties_set(
+        self: Self,
+    ) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.intersection_update({3, 4})
+        self.assertEqual(set(value), set())
+
+    def test_intersection_update_with_self_is_unchanged(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.intersection_update(value)
+        self.assertEqual(set(value), {1, 2, 3})
+
+
+class TestIsDisjoint(unittest.TestCase):
+    def test_disjoint_sets_return_true(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertTrue(value.isdisjoint({3, 4}))
+
+    def test_overlapping_sets_return_false(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertFalse(value.isdisjoint({2, 3}))
+
+    def test_empty_set_is_disjoint_from_populated_set(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot()
+        self.assertTrue(value.isdisjoint({1, 2}))
+
+    def test_isdisjoint_accepts_generator(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        other = (number for number in (3, 4))
+        self.assertTrue(value.isdisjoint(other))
+
+
+class TestIsSubset(unittest.TestCase):
+    def test_proper_subset_returns_true(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertTrue(value.issubset({1, 2, 3}))
+
+    def test_equal_set_is_subset(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertTrue(value.issubset({1, 2}))
+
+    def test_non_subset_returns_false(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 4})
+        self.assertFalse(value.issubset({1, 2, 3}))
+
+    def test_empty_set_is_subset_of_any_set(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot()
+        self.assertTrue(value.issubset({1, 2}))
+
+
+class TestIsSuperset(unittest.TestCase):
+    def test_proper_superset_returns_true(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        self.assertTrue(value.issuperset({1, 2}))
+
+    def test_equal_set_is_superset(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertTrue(value.issuperset({1, 2}))
+
+    def test_non_superset_returns_false(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertFalse(value.issuperset({1, 3}))
+
+    def test_every_set_is_superset_of_empty_set(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertTrue(value.issuperset(set()))
+
+
+class TestPop(unittest.TestCase):
+    def test_pop_returns_and_removes_only_element(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1})
+        result = value.pop()
+        self.assertEqual(result, 1)
+        self.assertEqual(set(value), set())
+
+    def test_pop_from_empty_set_raises_key_error(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot()
+        with self.assertRaises(KeyError):
+            value.pop()
+
+    def test_pop_removes_one_element_from_populated_set(self: Self) -> None:
+        original: set[int]
+        result: Any
+        value: MutableSetSlot[Any]
+        original = {1, 2, 3}
+        value = MutableSetSlot(original)
+        result = value.pop()
+        self.assertIn(result, original)
+        self.assertEqual(set(value), original - {result})
+
+    def test_repeated_pop_exhausts_set(self: Self) -> None:
+        popped: set[Any]
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        popped = {value.pop(), value.pop(), value.pop()}
+        self.assertEqual(popped, {1, 2, 3})
+        self.assertEqual(set(value), set())
+
+
+class TestRemove(unittest.TestCase):
+    def test_removes_existing_element(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.remove(2)
+        self.assertEqual(set(value), {1, 3})
+
+    def test_removing_missing_element_raises_key_error(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        with self.assertRaises(KeyError):
+            value.remove(3)
+        self.assertEqual(set(value), {1, 2})
+
+    def test_remove_returns_none(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        self.assertIsNone(value.remove(1))  # type: ignore[func-returns-value]
+
+    def test_removing_unhashable_element_raises_type_error(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        with self.assertRaises(Exception):
+            # in general you should not rely upon
+            # a TypeError or an AttributeError occuring
+            value.remove([1])
+        self.assertEqual(set(value), {1, 2})
+
+
+class TestSymmetricDifference(unittest.TestCase):
+    def test_symmetric_difference_excludes_shared_elements(self: Self) -> None:
+        result: Any
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        result = value.symmetric_difference({3, 4, 5})
+        self.assertEqual(set(result), {1, 2, 4, 5})
+
+    def test_symmetric_difference_of_disjoint_sets_is_union(
+        self: Self,
+    ) -> None:
+        result: Any
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        result = value.symmetric_difference({3, 4})
+        self.assertEqual(set(result), {1, 2, 3, 4})
+
+    def test_symmetric_difference_of_equal_sets_is_empty(self: Self) -> None:
+        result: Any
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        result = value.symmetric_difference({1, 2})
+        self.assertEqual(set(result), set())
+
+    def test_symmetric_difference_does_not_modify_original(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.symmetric_difference({3, 4})
+        self.assertEqual(set(value), {1, 2, 3})
+
+
+class TestSymmetricDifferenceUpdate(unittest.TestCase):
+    def test_symmetric_difference_update_excludes_shared_elements(
+        self: Self,
+    ) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2, 3})
+        value.symmetric_difference_update({3, 4, 5})
+        self.assertEqual(set(value), {1, 2, 4, 5})
+
+    def test_symmetric_difference_update_of_disjoint_sets_is_union(
+        self: Self,
+    ) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.symmetric_difference_update({3, 4})
+        self.assertEqual(set(value), {1, 2, 3, 4})
+
+    def test_symmetric_difference_update_with_equal_set_empties_set(
+        self: Self,
+    ) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.symmetric_difference_update({1, 2})
+        self.assertEqual(set(value), set())
+
+    def test_symmetric_difference_update_returns_none(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        result = value.symmetric_difference_update({2, 3})
+        self.assertIsNone(result)
+        self.assertEqual(set(value), {1, 3})
+
+
+class TestUnion(unittest.TestCase):
+    def test_union_combines_elements(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        result = value.union({2, 3})
+        self.assertEqual(set(result), {1, 2, 3})
+
+    def test_union_accepts_multiple_iterables(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1})
+        result = value.union({2}, [3, 4])
+        self.assertEqual(set(result), {1, 2, 3, 4})
+
+    def test_union_without_arguments_returns_same_contents(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        result = value.union()
+        self.assertEqual(set(result), {1, 2})
+        self.assertIsNot(result, value)
+
+    def test_union_does_not_modify_original(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.union({3, 4})
+        self.assertEqual(set(value), {1, 2})
+
+
+class TestUpdate(unittest.TestCase):
+    def test_update_adds_elements_from_iterable(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.update({2, 3, 4})
+        self.assertEqual(set(value), {1, 2, 3, 4})
+
+    def test_update_accepts_multiple_iterables(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1})
+        value.update({2}, [3, 4])
+        self.assertEqual(set(value), {1, 2, 3, 4})
+
+    def test_update_ignores_duplicate_elements(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1, 2})
+        value.update([1, 1, 2, 2])
+        self.assertEqual(set(value), {1, 2})
+
+    def test_update_returns_none(self: Self) -> None:
+        value: MutableSetSlot[Any]
+        value = MutableSetSlot({1})
+        result = value.update({2, 3})
+        self.assertIsNone(result)
+        self.assertEqual(set(value), {1, 2, 3})
+
+
+if __name__ == "__main__":
+    unittest.main()