def test_sub(self) -> None:
x = SetI32({1, 3, 4, 5})
y = SetI32({1, 2, 4, 6})
z = {1, 2, 4, 6}
self.assertEqual(x - y, set(x) - set(y))
self.assertEqual(y - x, set(y) - set(x))
self.assertEqual(z - x, set(y) - set(x))
self.assertEqual(x - z, set(x) - set(y))
self.assertEqual(x.difference(y), set(x) - set(y))
def test_xor(self) -> None:
x = SetI32({1, 3, 4, 5})
y = SetI32({1, 2, 4, 6})
z = {1, 2, 4, 6}
self.assertEqual(x ^ y, set(x) ^ set(y))
self.assertEqual(y ^ x, set(y) ^ set(x))
self.assertEqual(z ^ x, set(y) ^ set(x))
self.assertEqual(x ^ z, set(x) ^ set(y))
self.assertEqual(x.symmetric_difference(y), set(x) ^ set(y))
def test_or(self) -> None:
x = SetI32({1, 3, 4, 5})
y = SetI32({1, 2, 4, 6})
z = {1, 3, 4, 5}
self.assertEqual(x | y, set(x) | set(y))
self.assertEqual(y | x, set(y) | set(x))
self.assertEqual(z | y, set(x) | set(y))
self.assertEqual(y | z, set(y) | set(x))
self.assertEqual(x.union(y), set(x) | set(y))
def test_and(self) -> None:
x = SetI32({1, 3, 4, 5})
y = SetI32({1, 2, 4, 6})
z = {1, 2, 4, 6}
self.assertEqual(x & y, set(x) & set(y))
self.assertEqual(y & x, set(y) & set(x))
self.assertEqual(x & z, set(x) & set(y))
self.assertEqual(z & x, set(y) & set(x))
self.assertEqual(x.intersection(y), set(x) & set(y))
def test_comparisons(self) -> None:
x = SetI32({1, 2, 3, 4})
y = SetI32({1, 2, 3})
x2 = copy.copy(x)
y2 = {1, 2, 3}
def eq(t: AbstractSet[int], s: AbstractSet[int]) -> Tuple[bool, ...]:
return (t == s, set(t) == s, t == set(s), set(t) == set(s))
def neq(t: AbstractSet[int], s: AbstractSet[int]) -> Tuple[bool, ...]:
return (t != s, set(t) != s, t != set(s), set(t) != set(s))
def lt(t: AbstractSet[int], s: AbstractSet[int]) -> Tuple[bool, ...]:
return (t < s, set(t) < s, t < set(s), set(t) < set(s))
def gt(t: AbstractSet[int], s: AbstractSet[int]) -> Tuple[bool, ...]:
return (t > s, set(t) > s, t > set(s), set(t) > set(s))
def le(t: AbstractSet[int], s: AbstractSet[int]) -> Tuple[bool, ...]:
return (t <= s, set(t) <= s, t <= set(s), set(t) <= set(s))
def ge(t: AbstractSet[int], s: AbstractSet[int]) -> Tuple[bool, ...]:
return (t >= s, set(t) >= s, t >= set(s), set(t) >= set(s))
# = and != testing
self.assertTrue(all(eq(x, x2)))
self.assertTrue(all(eq(y2, y)))
self.assertTrue(all(neq(x, y)))
self.assertFalse(any(eq(x, y)))
self.assertFalse(any(neq(x, x2)))
self.assertFalse(any(neq(y2, y)))
# lt
self.assertTrue(all(lt(y, x)))
self.assertFalse(any(lt(x, y)))
self.assertFalse(any(lt(x, x2)))
self.assertFalse(any(lt(y2, y)))
# gt
self.assertTrue(all(gt(x, y)))
self.assertFalse(any(gt(y, x)))
self.assertFalse(any(gt(x, x2)))
self.assertFalse(any(gt(y2, y)))
# le
self.assertTrue(all(le(y, x)))
self.assertFalse(any(le(x, y)))
self.assertTrue(all(le(x, x2)))
self.assertTrue(all(le(y2, y)))
# ge
self.assertTrue(all(ge(x, y)))
self.assertFalse(any(ge(y, x)))
self.assertTrue(all(ge(x, x2)))
self.assertTrue(all(ge(y2, y)))
def test_pickle_set(self) -> None:
control = SetI32({1, 2, 3, 4})
self.pickle_round_robin(control)
def test_sub(self) -> None:
x = SetI32({1, 3, 4, 5})
y = SetI32({1, 2, 4, 6})
self.assertEqual(x - y, set(x) - set(y))
self.assertEqual(y - x, set(y) - set(x))
def test_xor(self) -> None:
x = SetI32({1, 3, 4, 5})
y = SetI32({1, 2, 4, 6})
self.assertEqual(x ^ y, set(x) ^ set(y))
self.assertEqual(y ^ x, set(y) ^ set(x))
def test_or(self) -> None:
x = SetI32({1, 3, 4, 5})
y = SetI32({1, 2, 4, 6})
self.assertEqual(x | y, set(x) | set(y))
self.assertEqual(y | x, set(y) | set(x))
def test_and(self) -> None:
x = SetI32({1, 3, 4, 5})
y = SetI32({1, 2, 4, 6})
self.assertEqual(x & y, set(x) & set(y))
self.assertEqual(y & x, set(y) & set(x))
def test_is_container(self) -> None:
self.assertIsInstance(SetI32Lists(), Container)
self.assertIsInstance(SetSetI32Lists(), Container)
self.assertIsInstance(SetI32(), Container)
