blob: fca92dea63e67bb24ef64c394234d96567683774 [file] [log] [blame]
 # 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".elems()) 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".elems()], ["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)]) # corner cases of parsing: assert.eq([x for x in range(12) if x%2 == 0 if x%3 == 0], [0, 6]) assert.eq([x for x in [1, 2] if lambda: None], [1, 2]) assert.eq([x for x in [1, 2] if (lambda: 3 if True else 4)], [1, 2]) # list function assert.eq(list(), []) assert.eq(list("ab".elems()), ["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 += def f5(): x = [] x += 1 assert.fails(f5, "unknown binary op: list \\+ int") # frozen list += iterable def f6(): x = [] freeze(x) x += [1] assert.fails(f6, "cannot apply \\+= to frozen list") # list += hasfields (hasfields is not iterable but defines list+hasfields) def f7(): x = [] x += hasfields() return x assert.eq(f7(), 42) # weird, but exercises a corner case in list+=x. # 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".elems()) # 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".elems()) 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".elems())) assert.eq(bananas[5::-2], list("aaa".elems())) assert.eq(bananas[4::-2], list("nnb".elems())) assert.eq(bananas[99::-2], list("snnb".elems())) assert.eq(bananas[100::-2], list("snnb".elems())) # 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")