Tipragot
628be439b8
Cela permet de ne pas avoir de problèmes de compatibilité car python est dans le git.
412 lines
8.9 KiB
Plaintext
412 lines
8.9 KiB
Plaintext
# 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 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 testListBuild]
|
|
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']
|
|
|
|
[case testListPrims]
|
|
from typing import List
|
|
|
|
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]
|
|
l.pop(2)
|
|
assert l == [1, 2, 3]
|
|
l.pop(-2)
|
|
assert l == [1, 3]
|
|
|
|
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]
|
|
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"]
|
|
|
|
[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]
|
|
|
|
[file driver.py]
|
|
|
|
from native import *
|
|
|
|
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]
|
|
def test() -> 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"]
|
|
|
|
[case testNextBug]
|
|
from typing import List, Optional
|
|
|
|
def test(x: List[int]) -> None:
|
|
res = next((i for i in x), None)
|
|
|
|
[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
|