-- Test cases for vec[i64]. These also partially cover other unboxed item types,

-- which use a similar runtime representation.

[case testVecI64BasicOps_librt_experimental]

from typing import Final, Any, Iterable, Tuple

from mypy_extensions import i64, i32

from librt.vecs import vec, append, remove, pop

from testutil import assertRaises

ERROR: Final = -113

def test_create_empty() -> None:

v = vec[i64]()

assert len(v) == 0

def test_create_from_list_and_get_item() -> None:

v = vec[i64]([])

assert len(v) == 0

v = vec[i64]([ERROR, 0, 255, int() + (2**63 - 1)])

assert len(v) == 4

assert v[0] == -113

assert v[1] == 0

assert v[2] == 255

assert v[3] == 2**63 - 1

v = vec[i64]([1, 2, 3, 4, 5, 6, 7, 8, 9])

assert len(v) == 9

for i in range(i64(9)):

assert v[i] == i + 1

def test_append() -> None:

v = vec[i64]()

v = append(v, int() + 3)

assert len(v) == 1

x: i64 = ERROR + int()

v = append(v, x)

assert len(v) == 2

assert v[0] == 3

assert v[1] == ERROR

v = vec[i64]()

for i in range(1024):

v = append(v, i * 3)

assert len(v) == 1024

for i in range(1024):

assert v[i] == i * 3

def test_get_item() -> None:

v = vec[i64]([3, 4])

x: i64 = int()

assert v[x] == 3

assert v[int()] == 3

x += 1

assert v[x] == 4

assert v[int() + 1] == 4

with assertRaises(IndexError):

v[x + 1]

with assertRaises(IndexError):

v[2]

with assertRaises(IndexError):

v[2**63 - 1]

def test_get_item_negative() -> None:

v = vec[i64]([3, 4])

x: i64 = int() - 1

assert v[x] == 4

assert v[int() - 2] == 3

x -= 1

assert v[x] == 3

assert v[int() - 1] == 4

with assertRaises(IndexError):

v[x - 1]

with assertRaises(IndexError):

v[-3]

with assertRaises(IndexError):

v[-2**63]

with assertRaises(IndexError):

v[int() - 3]

def test_set_item() -> None:

v = vec[i64]([3, 4])

v[0] = 0

assert v[0] == 0

x: i64 = int()

v[x] = 4

assert v[x] == 4

v[int()] = 5

assert v[int()] == 5

x += 1

v[x] = -5

assert v[x] == -5

v[1 + int()] = ERROR

assert v[1] == ERROR

with assertRaises(IndexError):

v[1 + x] = 6

with assertRaises(IndexError):

v[2 + int()] = 6

def test_set_item_negative() -> None:

v = vec[i64]([3, 4])

v[-1] = 0

assert v[-1] == 0

x: i64 = int() - 1

v[x] = 4

assert v[x] == 4

v[int() - 2] = 5

assert v[int() - 2] == 5

x -= 1

v[x] = -5

assert v[x] == -5

v[-1 + int()] = ERROR

assert v[-1] == ERROR

with assertRaises(IndexError):

v[x - 1] = 6

with assertRaises(IndexError):

v[int() - 3] = 6

def test_operator_assignment() -> None:

v = vec[i64]([3, 4])

x: i64 = int()

v[x] += 2

assert v[0] == 5

v[x + 1] -= 10

assert v[1] == -6

y = int()

v[y] += 6

assert v[y] == 11

v[y + 1] *= 2

assert v[1 + y] == -12

def test_box_and_unbox() -> None:

v = vec[i64]([3, 5])

o: Any = v

assert len(o) == 2

assert o[0] == 3

assert o[1] == 5

o[1] = 6

v2: vec[i64] = o

assert len(v2) == 2

assert v2[0] == 3

assert v2[1] == 6

o2: Any = "x"

with assertRaises(TypeError, "vec[i64] object expected; got str"):

v2 = o2

o3: Any = vec[str]([])

# TODO: Better message

with assertRaises(TypeError, "vec[i64] object expected; got vec"):

v2 = o3

def check_opt(x: vec[i64] | None, is_none: bool) -> None:

if is_none:

assert x is None

else:

# If statements ensure type narrowing doesn't leak between blocks

if int() + 1:

assert x is not None

assert len(x) == 1

assert x[0] == 5

if int() + 2:

assert isinstance(x, vec)

assert len(x) == 1

assert x[0] == 5

if isinstance(x, vec):

assert x[0] == 5

assert not is_none

else:

assert is_none

def test_vec_optional() -> None:

v = vec[i64]([5])

check_opt(None, True)

check_opt(v, False)

a1: Any = None

check_opt(a1, True)

a2: Any = v

check_opt(a2, False)

a3: Any = str

with assertRaises(TypeError):

check_opt(a3, False)

def check_union(x: vec[i64] | str, is_str: bool) -> None:

if is_str:

assert isinstance(x, str)

assert x == "ss"

else:

if int() + 1:

assert not isinstance(x, str)

assert len(x) == 1

assert x[0] == 5

if int() + 2:

assert isinstance(x, vec)

assert len(x) == 1

assert x[0] == 5

if isinstance(x, vec):

assert x[0] == 5

assert not is_str

else:

assert is_str

assert x == "ss"

def test_vec_union() -> None:

v = vec[i64]([5])

check_union("ss", True)

check_union(v, False)

a1: Any = "ss"

check_union(a1, True)

a2: Any = v

check_union(a2, False)

a3: Any = b"ss"

with assertRaises(TypeError):

check_union(a3, False)

a4: Any = vec[i32]()

with assertRaises(TypeError, 'union[vec[i64], str] object expected; got vec[i32]'):

check_union(a4, False)

def test_construct_from_list_multiply() -> None:

for i in range(50):

v = vec[i64]([i + 1] * i)

assert len(v) == i

for j in range(i):

assert v[j] == i + 1

for i in range(50):

v = vec[i64](i * [i - 1])

assert len(v) == i

for j in range(i):

assert v[j] == i - 1

def test_construct_from_list_comprehension() -> None:

for i in range(50):

l = [i * i for i in range(i)]

v = vec[i64]([n + 5 for n in l])

assert len(v) == i

for j in range(i):

assert v[j] == j * j + 5

def test_construct_from_range() -> None:

v = vec[i64](range(0))

assert v == vec[i64]()

v = vec[i64](range(5))

assert v == vec[i64]([0, 1, 2, 3, 4])

v = vec[i64](range(2, 5))

assert v == vec[i64]([2, 3, 4])

def test_construct_from_iterable() -> None:

for i in range(50):

it: Iterable[i64] = iter([i * i for i in range(i)])

v = vec[i64](it)

assert len(v) == i

for j in range(i):

assert v[j] == j * j

for i in range(50):

it2: Iterable[int] = iter([i * i for i in range(i)])

v = vec[i64](it2)

assert len(v) == i

for j in range(i):

assert v[j] == j * j

def test_equality() -> None:

v0 = vec[i64]()

v0b = vec[i64]()

v1 = vec[i64]([1])

v1b = vec[i64]([3])

assert v0 == v0

assert v1 == v1

assert v0 == v0b

assert v0 != v1

assert v1 != v1b

assert v1 != v0

def test_str_conversion() -> None:

v = vec[i64]()

assert str(v) == "vec[i64]([])"

assert repr(v) == "vec[i64]([])"

v = vec[i64]([126])

assert str(v) == "vec[i64]([126])"

v = append(v, -5)

assert str(v) == "vec[i64]([126, -5])"

v = append(v, ERROR)

assert str(v) == "vec[i64]([126, -5, -113])"

def test_for_loop() -> None:

for n in vec[i64]():

assert False

a = []

for n in vec[i64]([5]):

a.append(n)

assert a == [5]

v = vec[i64]([ERROR, 9, 8])

a = []

for n in v:

a.append(n)

assert a == [ERROR, 9, 8]

assert len(v) == 3

def test_contains() -> None:

v = vec[i64]()

x: i64 = int()

assert x not in v

v = vec[i64]([0])

assert x in v

assert x + 1 not in v

v2 = vec[i64]([ERROR, 7, 9])

assert x + ERROR in v2

assert x + 7 in v2

assert int() + 9 in v2

assert x not in v2

assert int() not in v2

def test_slicing() -> None:

v = vec[i64]()

assert v[:] == vec[i64]([])

assert v[1:] == vec[i64]([])

assert v[:-5] == vec[i64]([])

v = vec[i64]([0, 1, 2, 3, 4])

assert v[1:4] == vec[i64]([1, 2, 3])

assert v[2:-1] == vec[i64]([2, 3])

assert v[-2:-1] == vec[i64]([3])

assert v[1:] == vec[i64]([1, 2, 3, 4])

assert v[:-1] == vec[i64]([0, 1, 2, 3])

assert v[:] == v

assert v[:] is not v

assert v[5:] == vec[i64]()

assert v[100:] == vec[i64]()

assert v[0:5] ==v

assert v[0:5] is not v

assert v[2:100] == vec[i64]([2, 3, 4])

assert v[-100:2] == vec[i64]([0, 1])

assert v[5:100] == vec[i64]([])

assert v[50:100] == vec[i64]([])

assert v[-100:-50] == vec[i64]([])

def test_slicing_with_step() -> None:

v = vec[i64]([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

assert v[1:5:2] == vec[i64]([1, 3])

assert v[1:6:2] == vec[i64]([1, 3, 5])

assert v[5:1:-2] == vec[i64]([5, 3])

assert v[6:1:-2] == vec[i64]([6, 4, 2])

v = vec[i64]([0, 1, 2, 3, 4])

assert v[::-1] == vec[i64]([4, 3, 2, 1, 0])

with assertRaises(ValueError):

v[1:3:0]

def test_remove() -> None:

a = [4, 7, ERROR]

for i in a:

v = vec[i64](a)

v = remove(v, i)

assert v == vec[i64]([j for j in a if j != i])

v = vec[i64](a)

v = remove(v, 4)

v = remove(v, 7)

v = remove(v, ERROR)

assert v == vec[i64]()

with assertRaises(ValueError):

remove(v, 4)

v = append(v, 5)

with assertRaises(ValueError):

remove(v, 7)

v = remove(v, 5)

assert len(v) == 0

v = vec[i64]([1, 1, 1])

v = remove(v, 1)

assert v == vec[i64]([1, 1])

v = remove(v, 1)

assert v == vec[i64]([1])

v = remove(v, 1)

assert v == vec[i64]()

f: Any = 1.1

with assertRaises(TypeError):

remove(v, f)

s: Any = 'x'

with assertRaises(TypeError):

remove(v, s)

def test_pop_last() -> None:

v = vec[i64]([4, 7, ERROR])

v, n = pop(v)

assert n == ERROR

assert v == vec[i64]([4, 7])

v, n = pop(v)

assert n == 7

assert v == vec[i64]([4])

v, n = pop(v)

assert n == 4

assert v == vec[i64]()

with assertRaises(IndexError):

pop(v)

def test_pop_index() -> None:

v = vec[i64]([4, 7, 9, 15, 22])

v, n = pop(v, 0)

assert n == 4

assert v == vec[i64]([7, 9, 15, 22])

v, n = pop(v, -1)

assert n == 22

assert v == vec[i64]([7, 9, 15])

v, n = pop(v, 1)

assert n == 9

assert v == vec[i64]([7, 15])

with assertRaises(IndexError):

pop(v, 2)

with assertRaises(IndexError):

pop(v, -3)

v, n = pop(v, -2)

assert n == 7

assert v == vec[i64]([15])

v, n = pop(v, 0)

assert n == 15

assert v == vec[i64]()

def test_iter_and_next() -> None:

v = vec[i64]([1, 2, 3])

it = iter(v)

assert next(it) == 1

assert next(it) == 2

assert next(it) == 3

with assertRaises(StopIteration):

next(it)

# Multiple iterators on same vec

v = vec[i64]([10, 20])

it1 = iter(v)

it2 = iter(v)

assert next(it1) == 10

assert next(it2) == 10

assert next(it1) == 20

assert next(it2) == 20

# Empty vec iterator

it = iter(vec[i64]())

with assertRaises(StopIteration):

next(it)

def f(x: vec[i64]) -> None:

pass

def test_wrapper_arg_check() -> None:

f_any: Any = f

with assertRaises(TypeError):

f_any([])

v: Final = vec[i64]([5, 6])

def test_final() -> None:

assert v == vec[i64]([5, 6])

def fdefault(v: vec[i64] = vec[i64]([5])) -> vec[i64]:

return v

def test_default_arg() -> None:

assert fdefault() == vec[i64]([5])

assert fdefault(vec[i64]()) == vec[i64]()

f_any: Any = fdefault

assert f_any() == vec[i64]([5])

assert f_any(vec[i64]([6])) == vec[i64]([6])

def ftuple(b: bool) -> Tuple[vec[i64], vec[i64]]:

if b:

raise RuntimeError()

return vec[i64]([5]), vec[i64]()

def test_tuple() -> None:

t = ftuple(False)

assert len(t) == 2

assert t[0] == vec[i64]([5])

assert t[1] == vec[i64]()

a, b = t

assert a == t[0]

assert b == t[1]

with assertRaises(RuntimeError):

ftuple(True)