# Tests of Skylark 'list'

load("assert.sky", "assert", "freeze")

# literals
assert.eq([], [])
assert.eq([1], [1])
assert.eq([1,], [1])
assert.eq([1, 2], [1, 2])
assert.ne([1, 2, 3], [1, 2, 4])

# truth
assert.true([0])
assert.true(not [])

# indexing, x[i]
abc = list("abc".split_bytes())
assert.fails(lambda: abc[-4], "list index -1 out of range \\[0:3\\]")
assert.eq(abc[-3], "a")
assert.eq(abc[-2], "b")
assert.eq(abc[-1], "c")
assert.eq(abc[0], "a")
assert.eq(abc[1], "b")
assert.eq(abc[2], "c")
assert.fails(lambda: abc[3], "list index 3 out of range \\[0:3\\]")

# x[i] = ...
x3 = [0, 1, 2]
x3[1] = 2
x3[2] += 3
assert.eq(x3, [0, 2, 5])
def f2(): x3[3] = 4
assert.fails(f2, "out of range")
freeze(x3)
def f3(): x3[0] = 0
assert.fails(f3, "cannot assign to element of frozen list")
assert.fails(x3.clear, "cannot clear frozen list")

# list + list
assert.eq([1, 2, 3] + [3, 4, 5], [1, 2, 3, 3, 4, 5])
assert.fails(lambda: [1, 2] + (3, 4), "unknown.*list \+ tuple")
assert.fails(lambda: (1, 2) + [3, 4], "unknown.*tuple \+ list")

# list * int,  int * list
assert.eq(abc * 0, [])
assert.eq(abc * -1, [])
assert.eq(abc * 1, abc)
assert.eq(abc * 3, ["a", "b", "c", "a", "b", "c", "a", "b", "c"])
assert.eq(0 * abc, [])
assert.eq(-1 * abc, [])
assert.eq(1 * abc, abc)
assert.eq(3 * abc, ["a", "b", "c", "a", "b", "c", "a", "b", "c"])

# list comprehensions
assert.eq([2 * x for x in [1, 2, 3]], [2, 4, 6])
assert.eq([2 * x for x in [1, 2, 3] if x > 1], [4, 6])
assert.eq([(x, y) for x in [1, 2] for y in [3, 4]],
          [(1, 3), (1, 4), (2, 3), (2, 4)])
assert.eq([(x, y) for x in [1, 2] if x == 2 for y in [3, 4]],[(2, 3), (2, 4)])
assert.eq([2 * x for x in (1, 2, 3)], [2, 4, 6])
assert.eq([x for x in "abc".split_bytes()], ["a", "b", "c"])
assert.eq([x for x in {"a": 1, "b": 2}], ["a", "b"])
assert.eq([(y, x) for x, y in {1: 2, 3: 4}.items()], [(2, 1), (4, 3)])

# list function
assert.eq(list(), [])
assert.eq(list("ab".split_bytes()), ["a", "b"])

# A list comprehension defines a separate lexical block,
# whether at top-level...
a = [1, 2]
b = [a for a in [3, 4]]
assert.eq(a, [1, 2])
assert.eq(b, [3, 4])
# ...or local to a function.
def listcompblock():
  c = [1, 2]
  d = [c for c in [3, 4]]
  assert.eq(c, [1, 2])
  assert.eq(d, [3, 4])
listcompblock()

# list.pop
x4 = [1,2,3,4,5]
assert.eq(x4.pop(), 5)
assert.eq(x4, [1,2,3,4])
assert.eq(x4.pop(1), 2)
assert.eq(x4, [1,3,4])
assert.eq(x4.pop(0), 1)
assert.eq(x4, [3,4])

# TODO(adonovan): test uses of list as sequence
# (for loop, comprehension, library functions).

# x += y for lists is equivalent to x.extend(y).
# y may be a sequence.
# TODO: Test that side-effects of 'x' occur only once.
def list_extend():
  a = [1, 2, 3]
  b = a
  a = a + [4] # creates a new list
  assert.eq(a, [1, 2, 3, 4])
  assert.eq(b, [1, 2, 3]) # b is unchanged

  a = [1, 2, 3]
  b = a
  a += [4] # updates a (and thus b) in place
  assert.eq(a, [1, 2, 3, 4])
  assert.eq(b, [1, 2, 3, 4]) # alias observes the change

  a = [1, 2, 3]
  b = a
  a.extend([4]) # updates existing list
  assert.eq(a, [1, 2, 3, 4])
  assert.eq(b, [1, 2, 3, 4]) # alias observes the change
list_extend()

# Unlike list.extend(iterable), list += iterable makes its LHS name local.
a_list = []
def f4():
  a_list += [1] # binding use => a_list is a local var
assert.fails(f4, "local variable a_list referenced before assignment")

# list += <not iterable>
def f5():
  x = []
  x += 1
assert.fails(f5, "invalid operation: list \\+= int")

# frozen list += iterable
def f6():
  x = []
  freeze(x)
  x += [1]
assert.fails(f6, "cannot apply \\+= to frozen list")

# append
x5 = [1, 2, 3]
x5.append(4)
x5.append("abc")
assert.eq(x5, [1, 2, 3, 4, "abc"])

# extend
x5a = [1, 2, 3]
x5a.extend("abc".split_bytes()) # string
x5a.extend((True, False))       # tuple
assert.eq(x5a, [1, 2, 3, "a", "b", "c", True, False])

# list.insert
def insert_at(index):
  x = list(range(3))
  x.insert(index, 42)
  return x
assert.eq(insert_at(-99), [42, 0, 1, 2])
assert.eq(insert_at(-2), [0, 42, 1, 2])
assert.eq(insert_at(-1), [0, 1, 42, 2])
assert.eq(insert_at( 0), [42, 0, 1, 2])
assert.eq(insert_at( 1), [0, 42, 1, 2])
assert.eq(insert_at( 2), [0, 1, 42, 2])
assert.eq(insert_at( 3), [0, 1, 2, 42])
assert.eq(insert_at( 4), [0, 1, 2, 42])

# list.remove
def remove(v):
  x = [3, 1, 4, 1]
  x.remove(v)
  return x
assert.eq(remove(3), [1, 4, 1])
assert.eq(remove(1), [3, 4, 1])
assert.eq(remove(4), [3, 1, 1])
assert.fails(lambda: [3, 1, 4, 1].remove(42), "remove: element not found")

# list.index
bananas = list("bananas".split_bytes())
assert.eq(bananas.index('a'), 1) # bAnanas
assert.fails(lambda: bananas.index('d'), "value not in list")
# start
assert.eq(bananas.index('a', -1000), 1) # bAnanas
assert.eq(bananas.index('a', 0), 1)     # bAnanas
assert.eq(bananas.index('a', 1), 1)     # bAnanas
assert.eq(bananas.index('a', 2), 3)     # banAnas
assert.eq(bananas.index('a', 3), 3)     # banAnas
assert.eq(bananas.index('b', 0), 0)     # Bananas
assert.eq(bananas.index('n', -3), 4)    # banaNas
assert.fails(lambda: bananas.index('n', -2), "value not in list")
assert.eq(bananas.index('s', -2), 6)    # bananaS
assert.fails(lambda: bananas.index('b', 1), "value not in list")
# start, end
assert.eq(bananas.index('s', -1000, 7), 6) # bananaS
assert.fails(lambda: bananas.index('s', -1000, 6), "value not in list")
assert.fails(lambda: bananas.index('d', -1000, 1000), "value not in list")

# slicing, x[i:j:k]
assert.eq(bananas[6::-2], list("snnb".split_bytes()))
assert.eq(bananas[5::-2], list("aaa".split_bytes()))
assert.eq(bananas[4::-2], list("nnb".split_bytes()))
assert.eq(bananas[99::-2], list("snnb".split_bytes()))
assert.eq(bananas[100::-2], list("snnb".split_bytes()))
# TODO(adonovan): many more tests

# iterator invalidation
def iterator1():
  list = [0, 1, 2]
  for x in list:
    list[x] = 2 * x
  return list
assert.eq(iterator1(), [0, 2, 4]) # element updates are allowed

def iterator2():
  list = [0, 1, 2]
  for x in list:
    list.remove(x)
assert.fails(iterator2, "remove.*during iteration")

def iterator3():
  list = [0, 1, 2]
  for x in list:
    list.append(3)
assert.fails(iterator3, "append.*during iteration")

def iterator4():
  list = [0, 1, 2]
  for x in list:
    list.extend([3, 4])
assert.fails(iterator4, "extend.*during iteration")

def iterator5():
  def f(x):
    x.append(4)
  list = [1, 2, 3]
  _ = [f(list) for x in list]
assert.fails(iterator5, "append.*during iteration")