mypyc/test-data/run-vecs-misc-interp.test

[case testLibrtVecsMiscInterpreted_librt]
# Test cases for vec[<value primitive type>]. using generic operations.
# This simulates use from interpreted code.
#
# All specialized vec types share most of the implementation, so we don't try to
# duplicate all tests in run-vecs-i64-interp.test, which acts also as a more detailed
# test suite for specialized vec types.

import sys
from typing import Any
import typing

import librt.vecs
import mypy_extensions

from testutil import assertRaises

# Access via Any references to force generic operations
vec: Any = librt.vecs.vec
append: Any = librt.vecs.append
remove: Any = librt.vecs.remove
pop: Any = librt.vecs.pop
extend: Any = librt.vecs.extend
u8: Any = mypy_extensions.u8
i16: Any = mypy_extensions.i16
i32: Any = mypy_extensions.i32
i64: Any = mypy_extensions.i64

# Work around test stub limitations
Optional: Any = getattr(getattr(sys, "modules")["typing"], "Optional")

# TODO: Add some nested vec tests

ITEM_TYPES = [i64, u8, i16, i32, float, bool]

# Common tests for all item types

def test_bare_vec_cannot_be_constructed() -> None:
    with assertRaises(TypeError):
        vec()
    with assertRaises(TypeError):
        vec([])

def test_vec_indexing() -> None:
    for t in ITEM_TYPES:
        assert type(vec[t]) is type
        t1 = vec[t]
        t2 = vec[t]
        assert type(vec[t1]) is type(vec[t2])
        _ = [t1, t2]  # Ensure t1 and t2 are live here

        assert vec[t] is not vec
        if t is not i64:
            assert vec[t] is not vec[i64]
        else:
            assert vec[t] is not vec[i32]

        with assertRaises(TypeError):
            vec[Optional[t]]  # Not supported

def test_type_str() -> None:
    for t in ITEM_TYPES:
        name = t.__name__
        assert str(vec[t]) == f"<class 'vec[{name}]'>"
        assert repr(vec[t]) == f"<class 'vec[{name}]'>"

def test_construct_empty() -> None:
    for t in ITEM_TYPES:
        v = vec[t]()
        assert type(v) is vec[t]
        assert len(v) == 0

def test_isinstance() -> None:
    for t in ITEM_TYPES:
        v = vec[t]()
        assert isinstance(v, vec)
        assert not isinstance(vec[t], vec)
    assert not isinstance("x", vec)
    assert not isinstance(vec, vec)

def test_basic_int_operations() -> None:
    # All of the non-bool item types support int values 0 to 255
    for t in ITEM_TYPES:
        if t is bool:
            continue
        v = vec[t]([0, 4, 255])
        assert len(v) == 3
        assert v[0] == 0
        assert v[1] == 4
        assert v[2] == 255
        assert v[-1] == 255
        assert v[-2] == 4
        assert v[-3] == 0
        for bad_index in 3, -4, 1 << 100, -1 << 100:
            with assertRaises(IndexError):
                v[bad_index]
        with assertRaises(TypeError):
            v["0"]
        with assertRaises(TypeError):
            append(v, "0")

def test_construct_bool_from_list() -> None:
    v = vec[bool]([True, False, True])
    assert len(v) == 3
    assert v[0] is True
    assert v[1] is False
    assert v[2] is True

def test_equality() -> None:
    for t1 in ITEM_TYPES:
        for t2 in ITEM_TYPES:
            assert vec[t1]() != []
            if t1 is t2:
                assert vec[t1]() == vec[t2]()
            else:
                assert vec[t1]() != vec[t2]()

def test_repr() -> None:
    for t in ITEM_TYPES:
        name = t.__name__
        assert repr(vec[t]()) == f"vec[{name}]([])"

# vec[float] tests

def test_float_construct_from_initializer() -> None:
    v = vec[float]([123.5])
    assert len(v) == 1
    assert v[0] == 123.5
    v = vec[float](x + 1 for x in [5, 7.5, -8.5, 10])
    assert len(v) == 4
    assert v[0] == 6
    assert v[1] == 8.5
    assert v[2] == -7.5
    assert v[3] == 11
    with assertRaises(TypeError):
        vec[float](1)
    with assertRaises(TypeError):
        vec[float](['1'])
    with assertRaises(TypeError):
        vec[float]([None])

def test_float_append() -> None:
    v = vec[float]()
    v = append(v, 1.5)
    assert str(v) == "vec[float]([1.5])"
    v = append(v, -2)
    assert str(v) == "vec[float]([1.5, -2.0])"

def test_float_get_item() -> None:
    v = append(vec[float](), 44.5)
    assert v[0] == 44.5
    v = append(v, -56.5)
    assert v[0] == 44.5
    assert v[1] == -56.5

def test_float_remove() -> None:
    a = [4.5, 7, 9]
    for x in a:
        v = vec[float](a)
        v = remove(v, x)
        assert v == vec[float]([y for y in a if y != x])

def test_float_pop() -> None:
    v = vec[float]([4.5, 7, 9.5])
    v, n = pop(v)
    assert n == 9.5
    assert v == vec[float]([4.5, 7])

# vec[u8] tests

def test_u8_construct_from_initializer() -> None:
    v = vec[u8]([123])
    assert len(v) == 1
    assert v[0] == 123
    v = vec[u8](x for x in [0, 5, 255, 10])
    assert len(v) == 4
    assert v[0] == 0
    assert v[1] == 5
    assert v[2] == 255
    assert v[3] == 10
    with assertRaises(TypeError):
        vec[u8](1)
    with assertRaises(TypeError):
        vec[u8](['1'])
    with assertRaises(TypeError):
        vec[u8]([None])

def test_u8_append() -> None:
    v = vec[u8]()
    v = append(v, 5)
    assert str(v) == "vec[u8]([5])"
    v = append(v, 255)
    assert str(v) == "vec[u8]([5, 255])"

def test_u8_item_overflow() -> None:
    with assertRaises(OverflowError):
        vec[u8]([256])
    with assertRaises(OverflowError):
        vec[u8]([-1])
    with assertRaises(OverflowError):
        vec[u8]([2**100])
    with assertRaises(OverflowError):
        vec[u8]([-2**100])

def test_u8_get_item() -> None:
    v = append(vec[u8](), 44)
    assert v[0] == 44
    v = append(v, 238)
    assert v[0] == 44
    assert v[1] == 238

def test_u8_remove() -> None:
    a = [0, 7, 255]
    for x in a:
        v = vec[u8](a)
        v = remove(v, x)
        assert v == vec[u8]([y for y in a if y != x])

def test_u8_pop() -> None:
    v = vec[u8]([0, 7, 255])
    v, n = pop(v)
    assert n == 255
    assert v == vec[u8]([0, 7])

# vec[i16] tests

def test_i16_construct_from_initializer() -> None:
    v = vec[i16]([123])
    assert len(v) == 1
    assert v[0] == 123
    v = vec[i16](x for x in [0, 5, 32767, -32768])
    assert len(v) == 4
    assert v[0] == 0
    assert v[1] == 5
    assert v[2] == 32767
    assert v[3] == -32768
    with assertRaises(TypeError):
        vec[i16](1)
    with assertRaises(TypeError):
        vec[i16](['1'])
    with assertRaises(TypeError):
        vec[i16]([None])

def test_i16_append() -> None:
    v = vec[i16]()
    v = append(v, 5)
    assert str(v) == "vec[i16]([5])"
    v = append(v, 32767)
    assert str(v) == "vec[i16]([5, 32767])"

def test_i16_item_overflow() -> None:
    with assertRaises(OverflowError):
        vec[i16]([32768])
    with assertRaises(OverflowError):
        vec[i16]([-32769])
    with assertRaises(OverflowError):
        vec[i16]([2**100])
    with assertRaises(OverflowError):
        vec[i16]([-2**100])

def test_i16_get_item() -> None:
    v = append(vec[i16](), 44)
    assert v[0] == 44
    v = append(v, -238)
    assert v[0] == 44
    assert v[1] == -238

def test_i16_remove() -> None:
    a = [0, 7, -532, 32767]
    for x in a:
        v = vec[i16](a)
        v = remove(v, x)
        assert v == vec[i16]([y for y in a if y != x])

def test_i16_pop() -> None:
    v = vec[i16]([0, -7, 32767])
    v, n = pop(v)
    assert n == 32767
    assert v == vec[i16]([0, -7])

# vec[i32] tests

def test_i32_construct_from_initializer() -> None:
    v = vec[i32]([123])
    assert len(v) == 1
    assert v[0] == 123
    v = vec[i32](x for x in [0, 5, 2**31 - 1, -2**31])
    assert len(v) == 4
    assert v[0] == 0
    assert v[1] == 5
    assert v[2] == 2**31 - 1
    assert v[3] == -2**31
    with assertRaises(TypeError):
        vec[i32](1)
    with assertRaises(TypeError):
        vec[i32](['1'])
    with assertRaises(TypeError):
        vec[i32]([None])

def test_i32_append() -> None:
    v = vec[i32]()
    v = append(v, 5)
    assert str(v) == "vec[i32]([5])"
    v = append(v, 2**31 - 1)
    assert str(v) == "vec[i32]([5, 2147483647])"

def test_i32_item_overflow() -> None:
    with assertRaises(OverflowError):
        vec[i32]([2**31])
    with assertRaises(OverflowError):
        vec[i32]([-2**31 - 1])
    with assertRaises(OverflowError):
        vec[i32]([2**100])
    with assertRaises(OverflowError):
        vec[i32]([-2**100])

def test_i32_get_item() -> None:
    v = append(vec[i32](), 44)
    assert v[0] == 44
    v = append(v, -238)
    assert v[0] == 44
    assert v[1] == -238

def test_i32_remove() -> None:
    a = [0, 7, -532, 2**31 - 1]
    for x in a:
        v = vec[i32](a)
        v = remove(v, x)
        assert v == vec[i32]([y for y in a if y != x])

def test_i32_pop() -> None:
    v = vec[i32]([0, -7, 2**31 - 1])
    v, n = pop(v)
    assert n == 2**31 - 1
    assert v == vec[i32]([0, -7])

# vec[bool] tests

def test_bool_construct_from_initializer() -> None:
    v = vec[bool]([True])
    assert len(v) == 1
    assert v[0] == True
    v = vec[bool](x for x in [True, False, True])
    assert len(v) == 3
    assert v[0] is True
    assert v[1] is False
    assert v[2] is True
    with assertRaises(TypeError):
        vec[bool](1)
    with assertRaises(TypeError):
        vec[bool](['1'])
    with assertRaises(TypeError):
        vec[bool]([1])
    with assertRaises(TypeError):
        vec[bool]([None])

def test_bool_append() -> None:
    v = vec[bool]()
    v = append(v, False)
    assert str(v) == "vec[bool]([False])"
    v = append(v, True)
    assert str(v) == "vec[bool]([False, True])"

def test_bool_get_item() -> None:
    v = append(vec[bool](), True)
    assert v[0] is True
    v = append(v, False)
    assert v[0] is True
    assert v[1] is False

def test_bool_remove() -> None:
    a = [True, False]
    for x in a:
        v = vec[bool](a)
        v = remove(v, x)
        assert v == vec[bool]([y for y in a if y != x])

def test_bool_pop() -> None:
    v = vec[bool]([True, False, True])
    v, n = pop(v)
    assert n is True
    assert v == vec[bool]([True, False])

# Iteration tests for all item types

def test_iteration() -> None:
    # Test iteration for each primitive type
    for x in vec[float]():
        assert False
    a = []
    for x in vec[float]([1.5, 2.5, 3.5]):
        a.append(x)
    assert a == [1.5, 2.5, 3.5]

    for x in vec[u8]():
        assert False
    a = []
    for x in vec[u8]([1, 2, 255]):
        a.append(x)
    assert a == [1, 2, 255]

    for x in vec[i16]():
        assert False
    a = []
    for x in vec[i16]([-1000, 0, 1000]):
        a.append(x)
    assert a == [-1000, 0, 1000]

    for x in vec[i32]():
        assert False
    a = []
    for x in vec[i32]([-100000, 0, 100000]):
        a.append(x)
    assert a == [-100000, 0, 100000]

    for x in vec[bool]():
        assert False
    a = []
    for x in vec[bool]([True, False, True]):
        a.append(x)
    assert a == [True, False, True]

def test_iterator_protocol() -> None:
    # Test iter() and next() for float
    v_float = vec[float]([1.5, 2.5])
    it = iter(v_float)
    assert next(it) == 1.5
    assert next(it) == 2.5
    with assertRaises(StopIteration):
        next(it)

    # Test iter() and next() for u8
    v_u8 = vec[u8]([10, 20])
    it = iter(v_u8)
    assert next(it) == 10
    assert next(it) == 20
    with assertRaises(StopIteration):
        next(it)

    # Test iter() and next() for i16
    v_i16 = vec[i16]([-100, 100])
    it = iter(v_i16)
    assert next(it) == -100
    assert next(it) == 100
    with assertRaises(StopIteration):
        next(it)

    # Test iter() and next() for i32
    v_i32 = vec[i32]([-1000, 1000])
    it = iter(v_i32)
    assert next(it) == -1000
    assert next(it) == 1000
    with assertRaises(StopIteration):
        next(it)

    # Test bool specifically since values are True/False singletons
    v_bool = vec[bool]([True, False])
    it = iter(v_bool)
    assert next(it) is True
    assert next(it) is False
    with assertRaises(StopIteration):
        next(it)

def test_cap_empty() -> None:
    for t in ITEM_TYPES:
        v = vec[t](capacity=3)
        assert len(v) == 0
        assert v == vec[t]()

def test_cap_with_initializer() -> None:
    v = vec[float]([1.5, 2.5], capacity=3)
    assert len(v) == 2
    assert v[0] == 1.5
    assert v[1] == 2.5

    v = vec[u8]([10, 20], capacity=3)
    assert len(v) == 2
    assert v[0] == 10

    v = vec[i16]([-100, 100], capacity=3)
    assert len(v) == 2

    v = vec[i32]([1000, 2000], capacity=3)
    assert len(v) == 2

    v = vec[bool]([True, False], capacity=3)
    assert len(v) == 2
    assert v[0] is True
    assert v[1] is False

def test_cap_negative() -> None:
    for t in ITEM_TYPES:
        with assertRaises(ValueError):
            vec[t](capacity=-1)

def test_cap_buffer_reuse() -> None:
    # Verify buffer reuse within cap for each type
    v = vec[float]([1.5], capacity=3)
    old = v
    v = append(v, 2.5)
    v[0] = 9.5
    assert old[0] == 9.5  # shared buffer

    v = vec[u8]([10], capacity=3)
    old = v
    v = append(v, 20)
    v[0] = 99
    assert old[0] == 99

    v = vec[bool]([True], capacity=3)
    old = v
    v = append(v, False)
    v[0] = False
    assert old[0] is False

def test_extend_float() -> None:
    v = vec[float]([1.0])
    v = extend(v, [2.5, 3.5])
    assert v == vec[float]([1.0, 2.5, 3.5])

def test_extend_i32() -> None:
    v = vec[i32]([1])
    v = extend(v, [2, 3])
    assert v == vec[i32]([1, 2, 3])

def test_extend_i16() -> None:
    v = vec[i16]([1])
    v = extend(v, [2, 3])
    assert v == vec[i16]([1, 2, 3])

def test_extend_u8() -> None:
    v = vec[u8]([1])
    v = extend(v, [2, 3])
    assert v == vec[u8]([1, 2, 3])

def test_extend_bool() -> None:
    v = vec[bool]([True])
    v = extend(v, [False, True])
    assert v == vec[bool]([True, False, True])

[case testLibrtVecsBufferProtocol_librt]
import struct
from typing import Any

import librt.vecs
import mypy_extensions

from testutil import assertRaises

vec: Any = librt.vecs.vec
append: Any = librt.vecs.append
extend: Any = librt.vecs.extend
i64: Any = mypy_extensions.i64
i32: Any = mypy_extensions.i32
i16: Any = mypy_extensions.i16
u8: Any = mypy_extensions.u8
memoryview_: Any = eval('memoryview')

def test_buffer_u8() -> None:
    v = vec[u8]([1, 2, 3])
    mv = memoryview_(v)
    assert mv.format == "B"
    assert mv.itemsize == 1
    assert mv.readonly
    assert mv.ndim == 1
    assert mv.shape == (3,)
    assert list(mv) == [1, 2, 3]

def test_buffer_i64() -> None:
    v = vec[i64]([10, 20, -30])
    mv = memoryview_(v)
    assert mv.format == "q"
    assert mv.itemsize == 8
    assert mv.readonly
    assert mv.ndim == 1
    assert mv.shape == (3,)
    assert list(mv) == [10, 20, -30]

def test_buffer_i32() -> None:
    v = vec[i32]([5, -12])
    mv = memoryview_(v)
    assert mv.format == "i"
    assert mv.itemsize == 4
    assert mv.readonly
    assert list(mv) == [5, -12]

def test_buffer_i16() -> None:
    v = vec[i16]([100, -200])
    mv = memoryview_(v)
    assert mv.format == "h"
    assert mv.itemsize == 2
    assert mv.readonly
    assert list(mv) == [100, -200]

def test_buffer_float() -> None:
    v = vec[float]([1.5, -2.5])
    mv = memoryview_(v)
    assert mv.format == "d"
    assert mv.itemsize == 8
    assert mv.readonly
    assert list(mv) == [1.5, -2.5]

def test_buffer_bool() -> None:
    v = vec[bool]([True, False, True])
    mv = memoryview_(v)
    assert mv.format == "b"
    assert mv.itemsize == 1
    assert mv.readonly
    assert list(mv) == [1, 0, 1]

def test_buffer_empty() -> None:
    v = vec[i64]([])
    mv = memoryview_(v)
    assert mv.format == "q"
    assert len(mv) == 0
    assert mv.shape == (0,)
    assert list(mv) == []

def test_buffer_readonly() -> None:
    v = vec[u8]([1, 2, 3])
    mv = memoryview_(v)
    with assertRaises(TypeError):
        mv[0] = 99

def test_buffer_bytes_conversion() -> None:
    v = vec[u8]([72, 101, 108, 108, 111])
    assert bytes(v) == b"Hello"

def test_buffer_tobytes() -> None:
    v = vec[i32]([1, 2])
    mv = memoryview_(v)
    b = mv.tobytes()
    values = struct.unpack("ii", b)
    assert values == (1, 2)

def test_buffer_extend_from_shared_buffer() -> None:
    old = vec[u8]([1, 2], capacity=5)
    new = append(old, 3)
    v = extend(old, memoryview_(new))
    assert v == vec[u8]([1, 2, 1, 2, 3])
    assert new == vec[u8]([1, 2, 3])