def test_bigint(self):
l1 = range(1 << 100, (1 << 100) + 2)
s = IntSet(l1)
self.assertTrue(list(s) == list(l1))
l1 = IntSet([1 << x for x in range(50)])
self.assertTrue(len(l1) == 50)
def test_xor(self):
l1 = random.sample(range(10000), 2000)
l2 = random.sample(range(10000), 2000)
s1 = IntSet(l1)
s2 = IntSet(l2)
self.assertTrue(list(s1 ^ s2) == sorted(list(set(l1) ^ set(l2))))
self.assertRaises(TypeError, lambda: s1 ^ [])
def test_issuperset(self):
l1 = random.sample(range(10000), 2000)
l2 = random.sample(l1, 1000)
s1 = IntSet(l1)
s2 = IntSet(l2)
self.assertTrue(s1.issuperset(s2))
s2.add(100001)
self.assertFalse(s1.issuperset(s2))
self.assertRaises(TypeError, s1.issuperset, "123")
def test_union(self):
l1 = random.sample(range(10000), 2000)
l2 = random.sample(range(10000), 2000)
s1 = IntSet(l1)
s2 = set(l1)
self.assertTrue(
list(s1.union(IntSet(l2))) == sorted(list(s2.union(l2))))
self.assertTrue(list(s1.union(l2)) == sorted(list(s2.union(l2))))
self.assertRaises(TypeError, s1.union, 1)
self.assertRaises(TypeError, s1.union, ["1"])
def test_difference(self):
l1 = random.sample(range(10000), 2000)
l2 = random.sample(range(10000), 2000)
s1 = IntSet(l1)
s2 = set(l1)
self.assertTrue(
list(s1.difference(IntSet(l2))) == sorted(list(s2.difference(l2))))
self.assertTrue(
list(s1.difference(l2)) == sorted(list(s2.difference(l2))))
self.assertRaises(TypeError, s1.difference, 1)
self.assertRaises(TypeError, s1.difference, ["1"])
def test_intersection_update(self):
l1 = random.sample(range(10000), 2000)
l2 = random.sample(range(10000), 2000)
s1 = IntSet(l1)
s2 = set(l1)
s1.intersection_update(l2)
s2.intersection_update(l2)
self.assertTrue(list(s1) == sorted(list(s2)))
s1 = IntSet(l1)
s1.intersection_update(IntSet(l2))
self.assertTrue(list(s1) == sorted(list(s2)))
self.assertRaises(TypeError, s1.intersection_update, 1)
self.assertRaises(TypeError, s1.intersection_update, ["1"])
def test_contains(self):
l1 = random.sample(range(10000), 2000)
l2 = random.sample(l1, 100)
s = IntSet(l1)
for x in l2:
self.assertTrue(x in s)
self.assertRaises(TypeError, lambda: "1" in s)
def test_add(self):
l1 = random.sample(range(10000), 2000)
s = IntSet()
for x in l1:
s.add(x)
self.assertTrue(list(s) == sorted(l1))
self.assertRaises(TypeError, s.add, "1000000")
def test_init(self):
data = random.sample(range(10000), 2000)
self.assertTrue(list(IntSet(data)) == sorted(data))
self.assertTrue(list(IntSet(IntSet(data))) == sorted(data))
self.assertTrue(list(IntSet()) == [])
self.assertTrue(list(IntSet([])) == [])
self.assertTrue(list(IntSet(set(range(10)))) == list(range(10)))
self.assertTrue(list(IntSet(range(10))) == list(range(10)))
self.assertTrue(list(IntSet(tuple(range(10)))) == list(range(10)))
self.assertTrue(list(IntSet({1: 1})) == [1])
self.assertRaises(TypeError, IntSet, 1)
self.assertRaises(TypeError, IntSet, object())
self.assertRaises(TypeError, IntSet, ["1"])
def test_cmp(self):
l1 = random.sample(range(10000), 20)
s1 = IntSet(l1)
s2 = IntSet(l1)
self.assertEqual(s1, s2)
self.assertTrue(s1 >= s2)
self.assertTrue(s1 <= s2)
s2.add(10001)
self.assertNotEqual(s1, s2)
self.assertTrue(s2 > s1)
self.assertTrue(s1 < s2)
self.assertTrue(s2 >= s1)
self.assertTrue(s1 <= s2)
self.assertRaises(TypeError, lambda: s1 <= "1")
def test_remove(self):
l1 = random.sample(range(10000), 2000)
l2 = random.sample(l1, 300)
s1 = IntSet(l1)
s2 = set(l1)
for x in l2:
s1.remove(x)
s2.remove(x)
self.assertTrue(list(s1), sorted(s2))
self.assertRaises(KeyError, s1.remove, 10001)
self.assertRaises(TypeError, s1.remove, "1")
def test_update(self):
l1 = random.sample(range(10000), 2000)
l2 = random.sample(range(10000), 2000)
s2 = set(l1)
s2.update(l2)
s1 = IntSet(l1)
s1.update(l2)
self.assertTrue(list(s1) == sorted(list(s2)))
s1 = IntSet(l1)
s1.update(set(l2))
self.assertTrue(list(s1) == sorted(list(s2)))
s1 = IntSet(l1)
s1.update(IntSet(l2))
self.assertTrue(list(s1) == sorted(list(s2)))
self.assertRaises(TypeError, s1.update, 1)
self.assertRaises(TypeError, s1.update, ["1"])
s1 = IntSet([1 << 1000])
s1.update(range(255, 257))
self.assertEqual(s1.max(), 1 << 1000)
s1 = IntSet(range(10))
s1.update(range(1 << 100, (1 << 100) + 5))
self.assertEqual(s1.max(), (1 << 100) + 4)
def test_discard(self):
l1 = random.sample(range(10000), 2000)
l2 = random.sample(l1, 300)
s1 = IntSet(l1)
s2 = set(l1)
for x in l2:
s1.discard(x)
s2.discard(x)
self.assertTrue(list(s1), sorted(s2))
s1.discard(10001)
self.assertRaises(TypeError, s1.discard, "1")
def test_get_slice(self):
l1 = sorted(random.sample(range(10000), 2000))
s = IntSet(l1)
self.assertEqual(s[10:100], IntSet(l1[10:100]))
self.assertEqual(s[10:300], IntSet(l1[10:300]))
self.assertEqual(s[10:1000], IntSet(l1[10:1000]))
self.assertEqual(s[10:-10], IntSet(l1[10:-10]))
self.assertEqual(s[10:9], IntSet(l1[10:9]))
def test_max(self):
l1 = random.sample(range(10000), 2000)
s = IntSet(l1)
self.assertEqual(s.max(), max(l1))
self.assertRaises(ValueError, lambda: IntSet().max())
def test_len(self):
s = IntSet(random.sample(range(10000), 2000))
self.assertEqual(len(s), 2000)
def test_clear(self):
s = IntSet(random.sample(range(10000), 2000))
s.clear()
self.assertTrue(list(s) == [])
def test_get_item(self):
l1 = sorted(random.sample(range(10000), 2000))
s = IntSet(l1)
self.assertEqual(s[1000], l1[1000])
self.assertEqual(s[-500], l1[-500])
self.assertRaises(KeyError, lambda: s[3000])
assert not (l & r)
assert l.isdisjoint(r)
@given(IntSets, IntSets)
def test_removing_each_from_the_other_is_disjoint(x, y):
assume(x.intersects(y))
u = x - y
v = y - x
assert not (u & v)
assert u.isdisjoint(v)
@example(IntSet.empty())
@example(IntSet.single(1))
@example(IntSet([1, 2, 3, 6]))
@given(IntSets)
def test_pickling_works_correctly(x):
assert pickle.loads(pickle.dumps(x)) == x
@example(IntSet.interval(0, 10))
@example(IntSet([(0, 10), (15, 20)]))
@given(IntSets)
def test_copies_as_self(x):
assert copy(x) is x
assert deepcopy(x) is x
@given(st.lists(integers_in_range))
def test_iterable_equivalent_to_intervals_of_length_one(xs):
def test_extra_args_is_a_type_error():
with pytest.raises(TypeError):
IntSet(1, 2)
short_intervals = st.builds(
lambda start, length: assume(
start + length <= 2 ** 64) and (start, start + length),
integers_in_range, st.integers(0, SMALL))
interval_list = st.lists(intervals, average_size=10)
IntSets = st.builds(
IntSet.from_intervals, interval_list) | integers_in_range.map(
IntSet.single) | intervals.map(lambda x: IntSet.interval(*x))
@example(IntSet.empty())
@example(IntSet.single(1))
@example(IntSet([1, 2, 3, 6]))
@given(IntSets)
def test_pickling_works_correctly(x):
assert pickle.loads(pickle.dumps(x)) == x
@example(IntSet.interval(0, 10))
@example(IntSet([(0, 10), (15, 20)]))
@given(IntSets)
def test_copies_as_self(x):
assert copy(x) is x
assert deepcopy(x) is x
def test_deepcopy_collapses_reference_equality():
x = IntSet.from_iterable([1, 2, 3])
c val or clear val : valの集合を空集合化
inc val1 val2 : val1の集合の各要素にval2を加算
l val or len val : valの集合の要素数を表示
h or help : ヘルプを表示
q or quit : 終了
'''
print(help_str)
def value_check(length):
print(len(token))
return len(token) >= length
ss1 = IntSet()
ss2 = IntSet()
cmd = ""
while True:
cmd = input(">> ")
token = cmd.split() # 空白やタブでコマンドを区切る
f = token[0]
if f == 'i' or f == 'insert':
if len(token) >= 3:
if token[1] == '1':
ss1.insert_list(token[2:])
elif token[1] == '2':
ss2.insert_list(token[2:])
def test_negative_num(self):
data = random.sample(range(-10000, 0), 2000)
self.assertTrue(list(IntSet(data)) == sorted(data))
def test_iter(self):
data = random.sample(range(10000), 2000)
s = IntSet(data)
self.assertTrue(list(s) == sorted(data))
from intset import IntSet
s1 = IntSet()
s2 = IntSet()
def display():
print('s1:', s1, ' s2:', s2)
def reset():
s1.clear()
s2.clear()
s1.insert(2)
s1.insert(3)
s2.insert(3)
s2.insert(2)
s2.insert(5)
reset()
print("default value")
display()
s1.clear()
print("\ns1.clear()")
display()
reset()
lst = [6, 8, 9]
s1.insert_list(lst)
def test_copy(self):
l1 = random.sample(range(10000), 2000)
s1 = IntSet(l1)
s2 = s1.copy()
self.assertEqual(s1, s2)
def test_default_intset_is_empty():
assert IntSet() == IntSet.empty()
def test_large_array(self):
s1 = IntSet(range(1000000))
self.assertEqual(len(s1), 1000000)
def test_comparision_with_other_type_is_error():
with pytest.raises(TypeError):
IntSet([1, 2, 3]) <= [1, 2, 3]
def setUp(self):
random.seed(28)
self.set0 = IntSet(0) # empty
self.set5 = IntSet(5)
self.set4 = IntSet(4)