From 2b16bffb0539bd23dd900b66af2c407a1a4e8083 Mon Sep 17 00:00:00 2001
From: Bob Halley <halley@dnspython.org>
Date: Mon, 24 Jan 2022 12:54:20 -0800
Subject: [PATCH] add a few other missing things from the current python set
 API

---
 dns/set.py        | 13 +++++++++++++
 tests/test_set.py | 48 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 61 insertions(+)

diff --git a/dns/set.py b/dns/set.py
index 0ba15dfa..efa0819a 100644
--- a/dns/set.py
+++ b/dns/set.py
@@ -71,6 +71,11 @@ class Set:
 
         self.items.pop(item, None)
 
+    def pop(self):
+        """Remove an arbitrary item from the set."""
+        (k, v) = self.items.popitem()
+        return k
+
     def _clone(self):
         """Make a (shallow) copy of the set.
 
@@ -307,3 +312,11 @@ class Set:
             if item not in self.items:
                 return False
         return True
+
+    def isdisjoint(self, other):
+        if not isinstance(other, Set):
+            raise ValueError('other must be a Set instance')
+        for item in other.items:
+            if item in self.items:
+                return False
+        return True
diff --git a/tests/test_set.py b/tests/test_set.py
index 6fd0860b..103a6e9f 100644
--- a/tests/test_set.py
+++ b/tests/test_set.py
@@ -133,6 +133,19 @@ class SetTestCase(unittest.TestCase):
         e = S([])
         self.assertEqual(s1 ^ s2, e)
 
+    def testSymmetricDifference5(self):
+        s1 = S([1, 2, 3])
+        s2 = S([2, 4])
+        s1 ^= s2
+        e = S([1, 3, 4])
+        self.assertEqual(s1, e)
+
+    def testSymmetricDifference6(self):
+        s1 = S([1, 2, 3])
+        s1 ^= s1
+        e = S([])
+        self.assertEqual(s1, e)
+
     def testSubset1(self):
         s1 = S([1, 2, 3])
         s2 = S([3, 2, 1])
@@ -191,6 +204,35 @@ class SetTestCase(unittest.TestCase):
         s2 = S([1, 4])
         self.assertTrue(not s1.issuperset(s2))
 
+    def testDisjoint1(self):
+        s1 = S([1, 2, 3])
+        s2 = S([4])
+        self.assertTrue(s1.isdisjoint(s2))
+
+    def testDisjoint2(self):
+        s1 = S([1, 2, 3])
+        s2 = S([2, 4])
+        self.assertTrue(not s1.isdisjoint(s2))
+
+    def testDisjoint3(self):
+        s1 = S([1, 2, 3])
+        s2 = S([])
+        self.assertTrue(s1.isdisjoint(s2))
+
+    def testPop(self):
+        original = S([1, 2, 3])
+        s1 = original.copy()
+        item = s1.pop()
+        self.assertTrue(len(s1) == 2)
+        self.assertTrue(item in original)
+        item = s1.pop()
+        self.assertTrue(len(s1) == 1)
+        self.assertTrue(item in original)
+        item = s1.pop()
+        self.assertTrue(len(s1) == 0)
+        self.assertTrue(item in original)
+        self.assertRaises(KeyError, lambda: s1.pop())
+
     def testUpdate1(self):
         s1 = S([1, 2, 3])
         u = (4, 5, 6)
@@ -259,6 +301,8 @@ class SetTestCase(unittest.TestCase):
         s = S([1, 2, 3])
         self.assertRaises(ValueError, lambda: s.union_update(1))
         self.assertRaises(ValueError, lambda: s.intersection_update(1))
+        self.assertRaises(ValueError, lambda: s.difference_update(1))
+        self.assertRaises(ValueError, lambda: s.symmetric_difference_update(1))
 
     def testSelfUpdates(self):
         expected = S([1, 2, 3])
@@ -275,6 +319,10 @@ class SetTestCase(unittest.TestCase):
         self.assertRaises(ValueError, lambda: s.issubset(123))
         self.assertRaises(ValueError, lambda: s.issuperset(123))
 
+    def testBadDisjoint(self):
+        s = S([1, 2, 3])
+        self.assertRaises(ValueError, lambda: s.isdisjoint(123))
+
     def testIncrementalOperators(self):
         s = S([1, 2, 3])
         s += S([5, 4])
-- 
2.47.3