def test_reversed(self):
s = SortedFrozenSet([1, 3, 5, 7])
r = reversed(s)
self.assertEqual(next(r), 7)
self.assertEqual(next(r), 5)
self.assertEqual(next(r), 3)
self.assertEqual(next(r), 1)
self.assertRaises(StopIteration, lambda: next(r))
def test_reversed(self):
s = SortedFrozenSet([1, 3, 5, 7])
r = reversed(s)
assert next(r) == 7
assert next(r) == 5
assert next(r) == 3
assert next(r) == 1
with pytest.raises(StopIteration):
next(r)
def test_from_iterable(self):
def gen6842():
yield 6
yield 8
yield 4
yield 2
g = gen6842()
s = SortedFrozenSet(g)
def __init__(self, keys, value):
"""Initialize a RegularConstantCatalog.
The catalog is initialized by a description with an iterable series of
keys and a constant value to be associated with all the keys.
Args:
keys: An iterable series of distinct keys.
key_max: The maximum key.
key_stride: The difference between successive keys.
value: A value associated with all keys.
"""
self._keys = SortedFrozenSet(keys)
self._value = value
def make_sorted_distinct_sequence(iterable):
"""Create a sorted immutable sequence from an iterable series.
Args:
iterable: An iterable series of comparable values.
Returns:
An immutable collection which supports the Sized, Iterable,
Container and Sequence protocols.
"""
if isinstance(iterable, range):
if iterable.step > 0:
return iterable
else:
return reversed(iterable)
sorted_set = SortedFrozenSet(iterable)
if len(sorted_set) == 1:
return single_item_range(sorted_set[0])
stride = measure_stride(sorted_set)
if stride is not None:
start = sorted_set[0]
stop = sorted_set[-1] + stride
return range(start, stop, stride)
return sorted_set
def setUp(self):
self.s = SortedFrozenSet([7, 2, 1, 1, 9])
def test_with_duplicates(self):
s = SortedFrozenSet([5, 5, 5])
self.assertEqual(len(s), 1)
def test_one(self):
s = SortedFrozenSet([42])
self.assertEqual(len(s), 1)
def test_issuperset_negative(self):
s = SortedFrozenSet({1, 2})
t = [1, 2, 3]
self.assertFalse(s.issuperset(t))
def test_union(self):
s = SortedFrozenSet({1, 2, 3})
t = SortedFrozenSet({2, 3, 4})
self.assertEqual(s | t, SortedFrozenSet({1, 2, 3, 4}))
def test_isdisjoint_negative(self):
s = SortedFrozenSet({1, 2, 3})
t = [3, 4, 5]
self.assertFalse(s.isdisjoint(t))
def test_issuperset_negative(self):
s = SortedFrozenSet({1, 2})
t = [1, 2, 3]
self.assertFalse(s.issuperset(t))
def test_count_one(self):
s = SortedFrozenSet([1, 5, 7, 9])
self.assertEqual(s.count(7), 1)
def test_difference(self):
s = SortedFrozenSet({1, 2, 3})
t = [2, 3, 4]
self.assertEqual(s.difference(t), SortedFrozenSet({1}))
def test_symmetric_difference(self):
s = SortedFrozenSet({1, 2, 3})
t = [2, 3, 4]
self.assertEqual(s.symmetric_difference(t), SortedFrozenSet({1, 4}))
def test_union(self):
s = SortedFrozenSet({1, 2, 3})
t = [2, 3, 4]
self.assertEqual(s.union(t), SortedFrozenSet({1, 2, 3, 4}))
def test_intersection(self):
s = SortedFrozenSet({1, 2, 3})
t = [2, 3, 4]
self.assertEqual(s.intersection(t), SortedFrozenSet({2, 3}))
def test_isdisjoint_negative(self):
s = SortedFrozenSet({1, 2, 3})
t = [3, 4, 5]
self.assertFalse(s.isdisjoint(t))
def test_isdisjoint_positive(self):
s = SortedFrozenSet({1, 2, 3})
t = [4, 5, 6]
self.assertTrue(s.isdisjoint(t))
def test_count_zero(self):
s = SortedFrozenSet([1, 5, 7, 9])
self.assertEqual(s.count(11), 0)
def test_index_negative(self):
s = SortedFrozenSet([1, 5, 8, 9])
self.assertRaises(ValueError, lambda: s.index(15))
def test_difference(self):
s = SortedFrozenSet({1, 2, 3})
t = SortedFrozenSet({2, 3, 4})
self.assertEqual(s - t, SortedFrozenSet({1}))
def test_isdisjoint_positive(self):
s = SortedFrozenSet({1, 2, 3})
t = [4, 5, 6]
self.assertTrue(s.isdisjoint(t))
def test_union(self):
s = SortedFrozenSet({1, 2, 3})
t = [2, 3, 4]
self.assertEqual(s.union(t), SortedFrozenSet({1, 2, 3, 4}))
def test_intersection(self):
s = SortedFrozenSet({1, 2, 3})
t = SortedFrozenSet({2, 3, 4})
self.assertEqual(s & t, SortedFrozenSet({2, 3}))
def test_difference(self):
s = SortedFrozenSet({1, 2, 3})
t = [2, 3, 4]
self.assertEqual(s.difference(t), SortedFrozenSet({1}))
def test_symmetric_difference(self):
s = SortedFrozenSet({1, 2, 3})
t = SortedFrozenSet({2, 3, 4})
self.assertEqual(s ^ t, SortedFrozenSet({1, 4}))
def test_issuperset_positive(self):
s = SortedFrozenSet({1, 2, 3})
t = [1, 2, 3]
self.assertTrue(s.issuperset(t))
def test_intersection(self):
s = SortedFrozenSet({1, 2, 3})
t = [2, 3, 4]
self.assertEqual(s.intersection(t), SortedFrozenSet({2, 3}))
def test_identical(self):
s = SortedFrozenSet([10, 11, 12])
self.assertFalse(s != s)
def test_symmetric_difference(self):
s = SortedFrozenSet({1, 2, 3})
t = [2, 3, 4]
self.assertEqual(s.symmetric_difference(t), SortedFrozenSet({1, 4}))
def test_lt_negative(self):
s = SortedFrozenSet({1, 2, 3})
t = SortedFrozenSet({1, 2, 3})
self.assertFalse(s < t)
def test_empty(self):
s = SortedFrozenSet()
self.assertEqual(len(s), 0)
def test_le_lt_positive(self):
s = SortedFrozenSet({1, 2})
t = SortedFrozenSet({1, 2, 3})
self.assertTrue(s <= t)
def test_ten(self):
s = SortedFrozenSet(range(10))
self.assertEqual(len(s), 10)
def test_ge_eq_positive(self):
s = SortedFrozenSet({1, 2, 3})
t = SortedFrozenSet({1, 2, 3})
self.assertTrue(s >= t)
def test_empty(self):
s = SortedFrozenSet()
def test_ge_negative(self):
s = SortedFrozenSet({1, 2})
t = SortedFrozenSet({1, 2, 3})
self.assertFalse(s >= t)
def setUp(self):
self.s = SortedFrozenSet([1, 4, 9, 13, 15])
def test_issuperset_positive(self):
s = SortedFrozenSet({1, 2, 3})
t = [1, 2, 3]
self.assertTrue(s.issuperset(t))
def setUp(self):
self.s = SortedFrozenSet([6, 7, 3, 9])
def test_index_positive(self):
s = SortedFrozenSet([1, 5, 8, 9])
self.assertEqual(s.index(8), 2)