# Test cases for sets (compile and run)

[case testSets]

from typing import Set, List

def instantiateLiteral() -> Set[int]:

return {1, 2, 3, 5, 8}

def fromIterator() -> List[Set[int]]:

a = set([1, 3, 5])

b = set((1, 3, 5))

c = set({1: '1', 3: '3', 5: '5'})

d = set(x for x in range(1, 6, 2))

e = set((x for x in range(1, 6, 2)))

return [a, b, c, d, e]

def fromIterator2() -> Set[int]:

tmp_list = [1, 2, 3, 4, 5]

return set((x + 1) for x in ((y * 10) for y in (z for z in tmp_list if z < 4)))

def addIncrementing(s : Set[int]) -> None:

for a in [1, 2, 3]:

if a not in s:

s.add(a)

return

def replaceWith1(s : Set[int]) -> None:

s.clear()

s.add(1)

def remove1(s : Set[int]) -> None:

s.remove(1)

def discard1(s: Set[int]) -> None:

s.discard(1)

def pop(s : Set[int]) -> int:

return s.pop()

def update(s: Set[int], x: List[int]) -> None:

s.update(x)

[file driver.py]

from native import instantiateLiteral

from testutil import assertRaises

val = instantiateLiteral()

assert 1 in val

assert 2 in val

assert 3 in val

assert 5 in val

assert 8 in val

assert len(val) == 5

assert val == {1, 2, 3, 5, 8}

s = 0

for i in val:

s += i

assert s == 19

from native import fromIterator

sets = fromIterator()

for s in sets:

assert s == {1, 3, 5}

from native import fromIterator2

s = fromIterator2()

assert s == {11, 21, 31}

from native import addIncrementing

s = set()

addIncrementing(s)

assert s == {1}

addIncrementing(s)

assert s == {1, 2}

addIncrementing(s)

assert s == {1, 2, 3}

from native import replaceWith1

s = {3, 7, 12}

replaceWith1(s)

assert s == {1}

from native import remove1

import traceback

s = {1, 4, 6}

remove1(s)

assert s == {4, 6}

with assertRaises(KeyError, '1'):

remove1(s)

from native import discard1

s = {1, 4, 6}

discard1(s)

assert s == {4, 6}

discard1(s)

assert s == {4, 6}

from native import pop

s = {1, 2, 3}

x = pop(s)

assert len(s) == 2

assert x in [1, 2, 3]

y = pop(s)

assert len(s) == 1

assert y in [1, 2, 3]

assert x != y

z = pop(s)

assert len(s) == 0

assert z in [1, 2, 3]

assert x != z

assert y != z

with assertRaises(KeyError, 'pop from an empty set'):

pop(s)

from native import update

s = {1, 2, 3}

update(s, [5, 4, 3])

assert s == {1, 2, 3, 4, 5}

[case testFrozenSets]

from typing import FrozenSet, List, Any, cast

from testutil import assertRaises

def instantiateLiteral() -> FrozenSet[int]:

return frozenset((1, 2, 3, 5, 8))

def emptyFrozenSet1() -> FrozenSet[int]:

return frozenset()

def emptyFrozenSet2() -> FrozenSet[int]:

return frozenset(())

def fromIterator() -> List[FrozenSet[int]]:

a = frozenset([1, 3, 5])

b = frozenset((1, 3, 5))

c = frozenset({1, 3, 5})

d = frozenset({1: '1', 3: '3', 5: '5'})

e = frozenset(x for x in range(1, 6, 2))

f = frozenset((x for x in range(1, 6, 2)))

return [a, b, c, d, e, f]

def fromIterator2() -> FrozenSet[int]:

tmp_list = [1, 2, 3, 4, 5]

return frozenset((x + 1) for x in ((y * 10) for y in (z for z in tmp_list if z < 4)))

def castFrozenSet() -> FrozenSet[int]:

x: Any = frozenset((1, 2, 3, 5, 8))

return cast(FrozenSet, x)

def castFrozenSetError() -> FrozenSet[int]:

x: Any = {1, 2, 3, 5, 8}

return cast(FrozenSet, x)

def test_frozen_sets() -> None:

val = instantiateLiteral()

assert 1 in val

assert 2 in val

assert 3 in val

assert 5 in val

assert 8 in val

assert len(val) == 5

assert val == {1, 2, 3, 5, 8}

s = 0

for i in val:

s += i

assert s == 19

empty_set1 = emptyFrozenSet1()

assert empty_set1 == frozenset()

empty_set2 = emptyFrozenSet2()

assert empty_set2 == frozenset()

sets = fromIterator()

for s2 in sets:

assert s2 == {1, 3, 5}

s3 = fromIterator2()

assert s3 == {11, 21, 31}

val2 = castFrozenSet()

assert val2 == {1, 2, 3, 5, 8}

with assertRaises(TypeError, "frozenset object expected; got set"):

castFrozenSetError()

[case testFrozenSetsFromIterables]

from typing import FrozenSet

def f(x: int) -> int:

return x

def f1() -> FrozenSet[int]:

tmp_list = [1, 3, 5]

return frozenset(f(x) for x in tmp_list)

def f2() -> FrozenSet[int]:

tmp_tuple = (1, 3, 5)

return frozenset(f(x) for x in tmp_tuple)

def f3() -> FrozenSet[int]:

tmp_set = {1, 3, 5}

return frozenset(f(x) for x in tmp_set)

def f4() -> FrozenSet[int]:

tmp_dict = {1: '1', 3: '3', 5: '5'}

return frozenset(f(x) for x in tmp_dict)

def f5() -> FrozenSet[int]:

return frozenset(f(x) for x in range(1, 6, 2))

def f6() -> FrozenSet[int]:

return frozenset((f(x) for x in range(1, 6, 2)))

def g1(x: int) -> int:

return x

def g2(x: int) -> int:

return x * 10

def g3(x: int) -> int:

return x + 1

def g4() -> FrozenSet[int]:

tmp_list = [1, 2, 3, 4, 5]

return frozenset(g3(x) for x in (g2(y) for y in (g1(z) for z in tmp_list if z < 4)))

def test_frozen_sets_from_iterables() -> None:

val = frozenset({1, 3, 5})

assert f1() == val

assert f2() == val

assert f3() == val

assert f4() == val

assert f5() == val

assert f6() == val

assert g4() == frozenset({11, 21, 31})

[case testPrecomputedFrozenSets]

from typing import Final, Any

CONST: Final = "CONST"

non_const = "non_const"

def main_set(item: Any) -> bool:

return item in {None, False, 1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST}

def main_negated_set(item: Any) -> bool:

return item not in {None, False, 1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST}

def non_final_name_set(item: Any) -> bool:

return item in {non_const}

s = set()

for i in {None, False, 1, 2.0, "3", b"4", 5j, (6,), CONST}:

s.add(i)

def test_in_set() -> None:

for item in (None, False, 1, 2.0, "3", b"4", 5j, (6,), ((7,),), (), CONST):

assert main_set(item), f"{item!r} should be in set_main"

assert not main_negated_set(item), item

global non_const

assert non_final_name_set(non_const)

non_const = "updated"

assert non_final_name_set("updated")

def test_for_set() -> None:

assert not s ^ {None, False, 1, 2.0, "3", b"4", 5j, (6,), CONST}, s

[case testIsInstance]

from copysubclass import subset, subfrozenset

def test_built_in_set() -> None:

assert isinstance(set(), set)

assert isinstance({'one', 'two'}, set)

assert isinstance({'a', 1}, set)

assert isinstance(subset(), set)

assert isinstance(subset({'one', 'two'}), set)

assert isinstance(subset({'a', 1}), set)

assert not isinstance(frozenset(), set)

assert not isinstance({}, set)

assert not isinstance([], set)

assert not isinstance((1,2,3), set)

assert not isinstance({1:'a', 2:'b'}, set)

assert not isinstance(int() + 1, set)

assert not isinstance(str() + 'a', set)

def test_user_defined_set() -> None:

from userdefinedset import set

assert isinstance(set(), set)

assert not isinstance({set()}, set)

def test_built_in_frozenset() -> None:

assert isinstance(frozenset(), frozenset)

assert isinstance(frozenset({'one', 'two'}), frozenset)

assert isinstance(frozenset({'a', 1}), frozenset)

assert isinstance(subfrozenset(), frozenset)

assert isinstance(subfrozenset({'one', 'two'}), frozenset)

assert isinstance(subfrozenset({'a', 1}), frozenset)

assert not isinstance(set(), frozenset)

assert not isinstance({}, frozenset)

assert not isinstance([], frozenset)

assert not isinstance((1,2,3), frozenset)

assert not isinstance({1:'a', 2:'b'}, frozenset)

assert not isinstance(int() + 1, frozenset)

assert not isinstance(str() + 'a', frozenset)

[file copysubclass.py]

from typing import Any

class subset(set[Any]):

pass

class subfrozenset(frozenset[Any]):

pass

[file userdefinedset.py]

class set:

pass