# Test cases for lists (compile and run)

[case testListPlusEquals]

from typing import Any

def append(x: Any) -> None:

x += [1]

[file driver.py]

from native import append

x = []

append(x)

assert x == [1]

[case testListSum]

from typing import List

def sum(a: List[int], l: int) -> int:

sum = 0

i = 0

while i < l:

sum = sum + a[i]

i = i + 1

return sum

[file driver.py]

from native import sum

print(sum([], 0))

print(sum([3], 1))

print(sum([5, 6, -4], 3))

print(sum([2**128 + 5, -2**127 - 8], 2))

[out]

0

3

7

170141183460469231731687303715884105725

[case testListSet]

from typing import List

def copy(a: List[int], b: List[int], l: int) -> int:

i = 0

while i < l:

a[i] = b[i]

i = i + 1

return 0

[file driver.py]

from native import copy

a = [0, '']

copy(a, [-1, 5], 2)

print(1, a)

copy(a, [2**128 + 5, -2**127 - 8], 2)

print(2, a)

[out]

1 [-1, 5]

2 [340282366920938463463374607431768211461, -170141183460469231731687303715884105736]

[case testListClear]

from typing import List, Any

from copysubclass import subc

def test_list_clear() -> None:

l1 = [1, 2, 3, -4, 5]

l1.clear()

assert l1 == []

l1.clear()

assert l1 == []

l2: List[Any] = []

l2.clear()

assert l2 == []

l3 = [1, 2, 3, "abcdef"]

l3.clear()

assert l3 == []

# subclass testing

l4: subc = subc([1, 2, 3])

l4.clear()

assert l4 == []

[file copysubclass.py]

from typing import Any

class subc(list[Any]):

pass

[case testListCopy]

from typing import List

from copysubclass import subc

def test_list_copy() -> None:

l1 = [1, 2, 3, -4, 5]

l2 = l1.copy()

assert l1.copy() == l1

assert l1.copy() == l2

assert l1 == l2

assert l1.copy() == l2.copy()

l1 = l2.copy()

assert l1 == l2

assert l1.copy() == l2

assert l1 == [1, 2, 3, -4, 5]

l2 = [1, 2, -3]

l1 = []

assert l1.copy() == []

assert l2.copy() != l1

assert l2 == l2.copy()

l1 = l2

assert l1.copy().copy() == l2.copy().copy().copy()

assert l1.copy() == l2.copy()

l1 == [1, 2, -3].copy()

assert l1 == l2

l2 = [1, 2, 3].copy()

assert l2 != l1

l1 = [1, 2, 3]

assert l1.copy() == l2.copy()

l3 = [1, 2 , 3, "abcdef"]

assert l3 == l3.copy()

l4 = ["abc", 5, 10]

l4 = l3.copy()

assert l4 == l3

#subclass testing

l5: subc = subc([1, 2, 3])

l6 = l5.copy()

assert l6 == l5

l6 = [1, 2, "3", 4, 5]

l5 = subc([1,2,"3",4,5])

assert l5.copy() == l6.copy()

l6 = l5.copy()

assert l5 == l6

[file copysubclass.py]

from typing import Any

class subc(list[Any]):

pass

[case testSieve]

from typing import List

def primes(n: int) -> List[int]:

a = [1] * (n + 1)

a[0] = 0

a[1] = 0

i = 0

while i < n:

if a[i] == 1:

j = i * i

while j < n:

a[j] = 0

j = j + i

i = i + 1

return a

[file driver.py]

from native import primes

print(primes(3))

print(primes(13))

[out]

\[0, 0, 1, 1]

\[0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1]

[case testListPrimitives]

from testutil import assertRaises

def test_list_build() -> None:

# Currently LIST_BUILDING_EXPANSION_THRESHOLD equals to 10

# long list built by list_build_op

l1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

l1.pop()

l1.append(100)

assert l1 == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100]

# short list built by Setmem

l2 = [1, 2]

l2.append(3)

l2.pop()

l2.pop()

assert l2 == [1]

# empty list

l3 = []

l3.append('a')

assert l3 == ['a']

def test_append() -> None:

l = [1, 2]

l.append(10)

assert l == [1, 2, 10]

l.append(3)

l.append(4)

l.append(5)

assert l == [1, 2, 10, 3, 4, 5]

def test_pop_last() -> None:

l = [1, 2, 10, 3, 4, 5]

l.pop()

l.pop()

assert l == [1, 2, 10, 3]

def test_pop_index() -> None:

l = [1, 2, 10, 3]

assert l.pop(2) == 10

assert l == [1, 2, 3]

assert l.pop(-2) == 2

assert l == [1, 3]

assert l.pop(-2) == 1

assert l.pop(0) == 3

assert l == []

l = [int() + 1000, int() + 1001, int() + 1002]

assert l.pop(0) == 1000

assert l.pop(-1) == 1002

assert l == [1001]

def test_pop_index_errors() -> None:

l = [int() + 1000]

with assertRaises(IndexError):

l.pop(1)

with assertRaises(IndexError):

l.pop(-2)

with assertRaises(OverflowError):

l.pop(1 << 100)

with assertRaises(OverflowError):

l.pop(-(1 << 100))

def test_count() -> None:

l = [1, 3]

assert l.count(1) == 1

assert l.count(2) == 0

def test_insert() -> None:

l = [1, 3]

l.insert(0, 0)

assert l == [0, 1, 3]

l.insert(2, 2)

assert l == [0, 1, 2, 3]

l.insert(4, 4)

assert l == [0, 1, 2, 3, 4]

l.insert(-1, 5)

assert l == [0, 1, 2, 3, 5, 4]

l = [1, 3]

l.insert(100, 5)

assert l == [1, 3, 5]

l.insert(-100, 6)

assert l == [6, 1, 3, 5]

for long_int in 1 << 100, -(1 << 100):

try:

l.insert(long_int, 5)

except Exception as e:

# The error message is used by CPython

assert type(e).__name__ == 'OverflowError'

assert str(e) == 'Python int too large to convert to C ssize_t'

else:

assert False

def test_sort() -> None:

l = [1, 4, 3, 6, -1]

l.sort()

assert l == [-1, 1, 3, 4, 6]

l.sort()

assert l == [-1, 1, 3, 4, 6]

l = []

l.sort()

assert l == []

def test_reverse() -> None:

l = [1, 4, 3, 6, -1]

l.reverse()

assert l == [-1, 6, 3, 4, 1]

l.reverse()

assert l == [1, 4, 3, 6, -1]

l = []

l.reverse()

assert l == []

def test_remove() -> None:

l = [1, 3, 4, 3]

l.remove(3)

assert l == [1, 4, 3]

l.remove(3)

assert l == [1, 4]

try:

l.remove(3)

except ValueError:

pass

else:

assert False

def test_index() -> None:

l = [1, 3, 4, 3]

assert l.index(1) == 0

assert l.index(3) == 1

assert l.index(4) == 2

try:

l.index(0)

except ValueError:

pass

else:

assert False

[case testListOfUserDefinedClass]

class C:

x: int

def f() -> int:

c = C()

c.x = 5

a = [c]

d = a[0]

return d.x + 1

def g() -> int:

a = [C()]

a[0].x = 3

return a[0].x + 4

[file driver.py]

from native import f, g

print(f())

print(g())

[out]

6

7

[case testListOps]

from typing import Any, cast

from testutil import assertRaises

def test_slicing() -> None:

# Use dummy adds to avoid constant folding

zero = int()

two = zero + 2

s = ["f", "o", "o", "b", "a", "r"]

assert s[two:] == ["o", "b", "a", "r"]

assert s[:two] == ["f", "o"]

assert s[two:-two] == ["o", "b"]

assert s[two:two] == []

assert s[two:two + 1] == ["o"]

assert s[-two:] == ["a", "r"]

assert s[:-two] == ["f", "o", "o", "b"]

assert s[:] == ["f", "o", "o", "b", "a", "r"]

assert s[two:333] == ["o", "b", "a", "r"]

assert s[333:two] == []

assert s[two:-333] == []

assert s[-333:two] == ["f", "o"]

long_int: int = 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000

assert s[1:long_int] == ["o", "o", "b", "a", "r"]

assert s[long_int:] == []

assert s[-long_int:-1] == ["f", "o", "o", "b", "a"]

def in_place_add(l2: Any) -> list[Any]:

l1 = [1, 2]

l1 += l2

return l1

def test_add() -> None:

res = [1, 2, 3, 4]

assert [1, 2] + [3, 4] == res

with assertRaises(TypeError, 'can only concatenate list (not "tuple") to list'):

assert [1, 2] + cast(Any, (3, 4)) == res

l1 = [1, 2]

id_l1 = id(l1)

l1 += [3, 4]

assert l1 == res

assert id_l1 == id(l1)

assert in_place_add([3, 4]) == res

assert in_place_add((3, 4)) == res

assert in_place_add({3, 4}) == res

assert in_place_add({3: "", 4: ""}) == res

assert in_place_add(range(3, 5)) == res

def test_multiply() -> None:

l1 = [1]

assert l1 * 3 == [1, 1, 1]

assert 3 * l1 == [1, 1, 1]

l1 *= 3

assert l1 == [1, 1, 1]

[case testOperatorInExpression]

def tuple_in_int0(i: int) -> bool:

return i in []

def tuple_in_int1(i: int) -> bool:

return i in (1,)

def tuple_in_int3(i: int) -> bool:

return i in (1, 2, 3)

def tuple_not_in_int0(i: int) -> bool:

return i not in []

def tuple_not_in_int1(i: int) -> bool:

return i not in (1,)

def tuple_not_in_int3(i: int) -> bool:

return i not in (1, 2, 3)

def tuple_in_str(s: "str") -> bool:

return s in ("foo", "bar", "baz")

def tuple_not_in_str(s: "str") -> bool:

return s not in ("foo", "bar", "baz")

def list_in_int0(i: int) -> bool:

return i in []

def list_in_int1(i: int) -> bool:

return i in (1,)

def list_in_int3(i: int) -> bool:

return i in (1, 2, 3)

def list_not_in_int0(i: int) -> bool:

return i not in []

def list_not_in_int1(i: int) -> bool:

return i not in (1,)

def list_not_in_int3(i: int) -> bool:

return i not in (1, 2, 3)

def list_in_str(s: "str") -> bool:

return s in ("foo", "bar", "baz")

def list_not_in_str(s: "str") -> bool:

return s not in ("foo", "bar", "baz")

def list_in_mixed(i: object):

return i in [[], (), "", 0, 0.0, False, 0j, {}, set(), type]

def test_in_operator_various_cases() -> None:

assert not tuple_in_int0(0)

assert not tuple_in_int1(0)

assert tuple_in_int1(1)

assert not tuple_in_int3(0)

assert tuple_in_int3(1)

assert tuple_in_int3(2)

assert tuple_in_int3(3)

assert not tuple_in_int3(4)

assert tuple_not_in_int0(0)

assert tuple_not_in_int1(0)

assert not tuple_not_in_int1(1)

assert tuple_not_in_int3(0)

assert not tuple_not_in_int3(1)

assert not tuple_not_in_int3(2)

assert not tuple_not_in_int3(3)

assert tuple_not_in_int3(4)

assert tuple_in_str("foo")

assert tuple_in_str("bar")

assert tuple_in_str("baz")

assert not tuple_in_str("apple")

assert not tuple_in_str("pie")

assert not tuple_in_str("\0")

assert not tuple_in_str("")

assert not list_in_int0(0)

assert not list_in_int1(0)

assert list_in_int1(1)

assert not list_in_int3(0)

assert list_in_int3(1)

assert list_in_int3(2)

assert list_in_int3(3)

assert not list_in_int3(4)

assert list_not_in_int0(0)

assert list_not_in_int1(0)

assert not list_not_in_int1(1)

assert list_not_in_int3(0)

assert not list_not_in_int3(1)

assert not list_not_in_int3(2)

assert not list_not_in_int3(3)

assert list_not_in_int3(4)

assert list_in_str("foo")

assert list_in_str("bar")

assert list_in_str("baz")

assert not list_in_str("apple")

assert not list_in_str("pie")

assert not list_in_str("\0")

assert not list_in_str("")

assert list_in_mixed(0)

assert list_in_mixed([])

assert list_in_mixed({})

assert list_in_mixed(())

assert list_in_mixed(False)

assert list_in_mixed(0.0)

assert not list_in_mixed([1])

assert not list_in_mixed(object)

assert list_in_mixed(type)

[case testListBuiltFromGenerator]

from typing import Final

abc: Final = "abc"

def test_from_gen() -> None:

source_a = ["a", "b", "c"]

a = list(x + "f2" for x in source_a)

assert a == ["af2", "bf2", "cf2"]

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

b = [x * 2 for x in source_b]

assert b == [2, 4, 6, 8, 10]

source_c = [10, 20, 30]

c = [x + "f4" for x in (str(y) + "yy" for y in source_c)]

assert c == ["10yyf4", "20yyf4", "30yyf4"]

source_d = [True, False]

d = [not x for x in source_d]

assert d == [False, True]

source_e = [0, 1, 2]

e = list((x ** 2) for x in (y + 2 for y in source_e))

assert e == [4, 9, 16]

source_str = "abcd"

f = list("str:" + x for x in source_str)

assert f == ["str:a", "str:b", "str:c", "str:d"]

def test_known_length() -> None:

# not built from generator but doesnt need its own test either

built = [str(x) for x in [*abc, *"def", *b"ghi", ("j", "k"), *("l", "m", "n")]]

assert built == ['a', 'b', 'c', 'd', 'e', 'f', '103', '104', '105', "('j', 'k')", 'l', 'm', 'n']

[case testNext]

from typing import List

def get_next(x: List[int]) -> int:

return next((i for i in x), -1)

def test_next() -> None:

assert get_next([]) == -1

assert get_next([1]) == 1

assert get_next([3,2,1]) == 3

[case testListGetItemWithBorrow]

from typing import List

class D:

def __init__(self, n: int) -> None:

self.n = n

class C:

def __init__(self, d: D) -> None:

self.d = d

def test_index_with_literal() -> None:

d1 = D(1)

d2 = D(2)

a = [C(d1), C(d2)]

d = a[0].d

assert d is d1

d = a[1].d

assert d is d2

d = a[-1].d

assert d is d2

d = a[-2].d

assert d is d1

[case testSorted]

from typing import List

def test_list_sort() -> None:

l1 = [2, 1, 3]

id_l1 = id(l1)

l1.sort()

assert l1 == [1, 2, 3]

assert id_l1 == id(l1)

def test_sorted() -> None:

res = [1, 2, 3]

l1 = [2, 1, 3]

id_l1 = id(l1)

s_l1 = sorted(l1)

assert s_l1 == res

assert id_l1 != id(s_l1)

assert l1 == [2, 1, 3]

assert sorted((2, 1, 3)) == res

assert sorted({2, 1, 3}) == res

assert sorted({2: "", 1: "", 3: ""}) == res

[case testIsInstance]

from copysubclass import subc

def test_built_in() -> None:

assert isinstance([], list)

assert isinstance([1,2,3], list)

assert isinstance(['a','b'], list)

assert isinstance(subc(), list)

assert isinstance(subc([1,2,3]), list)

assert isinstance(subc(['a','b']), list)

assert not isinstance({}, list)

assert not isinstance((), list)

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

assert not isinstance(('a','b'), list)

assert not isinstance(1, list)

assert not isinstance('a', list)

def test_user_defined() -> None:

from userdefinedlist import list

assert isinstance(list(), list)

assert not isinstance([list()], list)

[file copysubclass.py]

from typing import Any

class subc(list[Any]):

pass

[file userdefinedlist.py]

class list:

pass