Examples/test-suite/python/li_std_containers_int_runme.py

# Check std::vector and std::list behaves the same as Python iterable
# types (list)

from li_std_containers_int import *
import sys


def failed(a, b, msg):
    raise RuntimeError(msg + " " + str(list(a)) + " " + str(list(b)))


def compare_sequences(a, b):
    if len(a) != len(b):
        failed(a, b, "different sizes")
    for i in range(len(a)):
        if a[i] != b[i]:
            failed(a, b, "elements are different")


def compare_containers(pythonlist, swigvector, swiglist):
    compare_sequences(pythonlist, swigvector)
    compare_sequences(pythonlist, swiglist)

# Check std::vector and std::list assignment behaves same as Python list
# assignment including exceptions


def container_insert_step(i, j, step, newval):
    ps = list(range(6))
    iv = vector_int(ps)
    il = list_int(ps)

    # Python slice
    try:
        if step == None:
            if j == None:
                ps[i] = newval
            else:
                ps[i:j] = newval
        else:
            if j == None:
                ps[i::step] = newval
            else:
                ps[i:j:step] = newval
        ps_error = None
    except ValueError as e:
        ps_error = e
    except IndexError as e:
        ps_error = e

    # std::vector<int>
    try:
        if step == None:
            if j == None:
                iv[i] = newval
            else:
                iv[i:j] = newval
        else:
            if j == None:
                iv[i::step] = newval
            else:
                iv[i:j:step] = newval
        iv_error = None
    except ValueError as e:
        iv_error = e
    except IndexError as e:
        iv_error = e

    # std::list<int>
    try:
        if step == None:
            if j == None:
                il[i] = newval
            else:
                il[i:j] = newval
        else:
            if j == None:
                il[i::step] = newval
            else:
                il[i:j:step] = newval
        il_error = None
    except ValueError as e:
        il_error = e
    except IndexError as e:
        il_error = e

    if not((type(ps_error) == type(iv_error)) and (type(ps_error) == type(il_error))):
        raise RuntimeError("ValueError exception not consistently thrown: " + \
            str(ps_error) + " " + str(iv_error) + " " + str(il_error))

    compare_containers(ps, iv, il)


# Check std::vector and std::list delete behaves same as Python list
# delete including exceptions
def container_delete_step(i, j, step):
    ps = list(range(6))
    iv = vector_int(ps)
    il = list_int(ps)

    # Python slice
    try:
        if step == None:
            if j == None:
                del ps[i]
            else:
                del ps[i:j]
        else:
            if j == None:
                del ps[i::step]
            else:
                del ps[i:j:step]
        ps_error = None
    except ValueError as e:
        ps_error = e
    except IndexError as e:
        ps_error = e

    # std::vector<int>
    try:
        if step == None:
            if j == None:
                del iv[i]
            else:
                del iv[i:j]
        else:
            if j == None:
                del iv[i::step]
            else:
                del iv[i:j:step]
        iv_error = None
    except ValueError as e:
        iv_error = e
    except IndexError as e:
        iv_error = e

    # std::list<int>
    try:
        if step == None:
            if j == None:
                del il[i]
            else:
                del il[i:j]
        else:
            if j == None:
                del il[i::step]
            else:
                del il[i:j:step]
        il_error = None
    except ValueError as e:
        il_error = e
    except IndexError as e:
        il_error = e

    if not((type(ps_error) == type(iv_error)) and (type(ps_error) == type(il_error))):
        raise RuntimeError("ValueError exception not consistently thrown: " + \
            str(ps_error) + " " + str(iv_error) + " " + str(il_error))

    compare_containers(ps, iv, il)


ps = [0, 1, 2, 3, 4, 5]

iv = vector_int(ps)
il = list_int(ps)

# slices
compare_containers(ps[0:0], iv[0:0], il[0:0])
compare_containers(ps[1:1], iv[1:1], il[1:1])
compare_containers(ps[1:3], iv[1:3], il[1:3])
compare_containers(ps[2:4], iv[2:4], il[2:4])
compare_containers(ps[0:3], iv[0:3], il[0:3])
compare_containers(ps[3:6], iv[3:6], il[3:6])
compare_containers(ps[3:10], iv[3:10], il[3:10])  # beyond end of range

# before beginning of range (negative indexing)
compare_containers(ps[-1:7], iv[-1:7], il[-1:7])
compare_containers(ps[-2:7], iv[-2:7], il[-2:7])
compare_containers(ps[-5:7], iv[-5:7], il[-5:7])
compare_containers(ps[-6:7], iv[-6:7], il[-6:7])

# before beginning of range (negative indexing, negative index is >
# container size)
compare_containers(ps[-7:7], iv[-7:7], il[-7:7])
compare_containers(ps[-100:7], iv[-100:7], il[-100:7])

compare_containers(ps[3:], iv[3:], il[3:])
compare_containers(ps[:3], iv[:3], il[:3])
compare_containers(ps[:], iv[:], il[:])
compare_containers(ps[-3:], iv[-3:], il[-3:])
compare_containers(ps[-7:], iv[-7:], il[-7:])
compare_containers(ps[:-1], iv[:-1], il[:-1])
compare_containers(ps[:-7], iv[:-7], il[:-7])

# step slicing
compare_containers(ps[1:5:1], iv[1:5:1], il[1:5:1])
compare_containers(ps[1:5:2], iv[1:5:2], il[1:5:2])
compare_containers(ps[1:5:3], iv[1:5:3], il[1:5:3])
compare_containers(ps[1:5:4], iv[1:5:4], il[1:5:4])
compare_containers(ps[1:6:5], iv[1:6:5], il[1:6:5])
compare_containers(ps[1:7:5], iv[1:7:5], il[1:7:5])
compare_containers(ps[-1:7:1], iv[-1:7:1], il[-1:7:1])
compare_containers(ps[-1:7:2], iv[-1:7:2], il[-1:7:2])
compare_containers(ps[-6:7:2], iv[-6:7:2], il[-6:7:2])
compare_containers(ps[-100:7:2], iv[-100:7:2], il[-100:7:2])
compare_containers(ps[::1], iv[::1], il[::1])
compare_containers(ps[::2], iv[::2], il[::2])

compare_containers(ps[::-1], iv[::-1], il[::-1])
compare_containers(ps[6::-1], iv[6::-1], il[6::-1])
compare_containers(ps[:-3:-1], iv[:-3:-1], il[:-3:-1])
compare_containers(ps[:-6:-1], iv[:-6:-1], il[:-6:-1])
compare_containers(ps[:-7:-1], iv[:-7:-1], il[:-7:-1])
compare_containers(ps[:-8:-1], iv[:-8:-1], il[:-8:-1])
compare_containers(ps[:-100:-1], iv[:-100:-1], il[:-100:-1])
compare_containers(ps[4:6:-1], iv[4:6:-1], il[4:6:-1])
compare_containers(ps[4:5:-1], iv[4:5:-1], il[4:5:-1])
compare_containers(ps[4:4:-1], iv[4:4:-1], il[4:4:-1])
compare_containers(ps[4:3:-1], iv[4:3:-1], il[4:3:-1])
compare_containers(ps[4:2:-1], iv[4:2:-1], il[4:2:-1])
compare_containers(ps[100:104:-1], iv[100:104:-1], il[100:104:-1])
compare_containers(ps[104:100:-1], iv[104:100:-1], il[104:100:-1])
compare_containers(ps[-100:-104:-1], iv[-100:-104:-1], il[-100:-104:-1])
compare_containers(ps[-104:-100:-1], iv[-104:-100:-1], il[-104:-100:-1])
compare_containers(ps[::-2], iv[::-2], il[::-2])
compare_containers(ps[::-3], iv[::-3], il[::-3])
compare_containers(ps[::-4], iv[::-4], il[::-4])
compare_containers(ps[::-5], iv[::-5], il[::-5])


# insert sequences (growing, shrinking and staying same size)
for start in [-102, -100, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 100, 102]:
    # single element set/replace
    container_insert_step(start, None, None, 111)
    for end in [-102, -100, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 100, 102]:
        container_insert_step(
            start, end, None, [111, 222, 333, 444, 555, 666, 777])
        container_insert_step(start, end, None, [111, 222, 333, 444, 555, 666])
        container_insert_step(start, end, None, [111, 222, 333, 444, 555])
        container_insert_step(start, end, None, [111, 222, 333, 444])
        container_insert_step(start, end, None, [111, 222, 333])
        container_insert_step(start, end, None, [111, 222])
        container_insert_step(start, end, None, [111])
        container_insert_step(start, end, None, [])

# delete sequences (growing, shrinking and staying same size)
for start in [-102, -100, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 100, 102]:
    # single element delete
    container_delete_step(start, None, None)
    for end in [-102, -100, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 100, 102]:
        container_delete_step(start, end, None)
        for step in range(-7, 7):
            container_delete_step(start, end, step)

ps = list(range(6))
iv = vector_int(ps)
il = list_int(ps)
del ps[:]
del iv[:]
del il[:]
compare_containers(ps, iv, il)

for end in range(7):
    for step in range(-7, 7):
        for start in range(7):
            container_insert_step(
                start, end, step, [111, 222, 333, 444, 555, 666, 777])
            container_insert_step(
                start, end, step, [111, 222, 333, 444, 555, 666])
            container_insert_step(start, end, step, [111, 222, 333, 444, 555])
            container_insert_step(start, end, step, [111, 222, 333, 444])
            container_insert_step(start, end, step, [111, 222, 333])
            container_insert_step(start, end, step, [111, 222])
            container_insert_step(start, end, step, [111])
            container_insert_step(start, end, step, [])

try:
    x = iv[::0]
    raise RuntimeError("Zero step not caught")
except ValueError:
    pass

# Construct from set (Iterator protocol, not Sequence protocol)
ps = {11, 22, 33}
iv = vector_int(ps)
il = vector_int(ps)
compare_containers(list(ps), iv, il)

# pop removes and returns the last element, or the one at the index given, like a Python list
pythonlist = [11, 22, 33, 44]
iv = vector_int(pythonlist)
il = list_int(pythonlist)

if iv.pop() != pythonlist.pop() or il.pop() != 44:
    raise RuntimeError("pop did not return the last element")
compare_containers(pythonlist, iv, il)

if iv.pop(0) != pythonlist.pop(0) or il.pop(0) != 11:
    raise RuntimeError("pop(0) did not return the first element")
compare_containers(pythonlist, iv, il)

# The last element is reached without walking the container, by the default index and by a given one
pythonlist = [11, 22, 33, 44]
iv = vector_int(pythonlist)
il = list_int(pythonlist)

if iv.pop(len(pythonlist) - 1) != pythonlist.pop(len(pythonlist) - 1) or il.pop(3) != 44:
    raise RuntimeError("pop did not return the element at the last index")
compare_containers(pythonlist, iv, il)

if iv.pop(-2) != pythonlist.pop(-2) or il.pop(-2) != 22:
    raise RuntimeError("pop(-2) did not return the second to last element")
compare_containers(pythonlist, iv, il)